diff options
Diffstat (limited to 'third_party/vulkan/vulkan.hpp')
| -rw-r--r-- | third_party/vulkan/vulkan.hpp | 35695 |
1 files changed, 0 insertions, 35695 deletions
diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp deleted file mode 100644 index 5b7bc7203..000000000 --- a/third_party/vulkan/vulkan.hpp +++ /dev/null @@ -1,35695 +0,0 @@ -// Copyright (c) 2015-2018 The Khronos Group Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_HPP -#define VULKAN_HPP - -#include <algorithm> -#include <array> -#include <cassert> -#include <cstddef> -#include <cstdint> -#include <cstring> -#include <initializer_list> -#include <string> -#include <system_error> -#include <tuple> -#include <type_traits> -#include <vulkan/vulkan.h> -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE -# include <memory> -# include <vector> -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -static_assert( VK_HEADER_VERSION == 68 , "Wrong VK_HEADER_VERSION!" ); - -// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. -// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION -#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) -# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION ) -# define VULKAN_HPP_TYPESAFE_CONVERSION -# endif -#endif - -#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS) -# if defined(__clang__) -# if __has_feature(cxx_unrestricted_unions) -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# elif defined(__GNUC__) -# define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) -# if 40600 <= GCC_VERSION -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# elif defined(_MSC_VER) -# if 1900 <= _MSC_VER -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# endif -#endif - -#if !defined(VULKAN_HPP_INLINE) -# if defined(__clang___) -# if __has_attribute(always_inline) -# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__ -# else -# define VULKAN_HPP_INLINE inline -# endif -# elif defined(__GNUC__) -# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__ -# elif defined(_MSC_VER) -# define VULKAN_HPP_INLINE __forceinline -# else -# define VULKAN_HPP_INLINE inline -# endif -#endif - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) -# define VULKAN_HPP_TYPESAFE_EXPLICIT -#else -# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit -#endif - - -#if !defined(VULKAN_HPP_NAMESPACE) -#define VULKAN_HPP_NAMESPACE vk -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - - template <typename FlagBitsType> struct FlagTraits - { - enum { allFlags = 0 }; - }; - - template <typename BitType, typename MaskType = VkFlags> - class Flags - { - public: - Flags() - : m_mask(0) - { - } - - Flags(BitType bit) - : m_mask(static_cast<MaskType>(bit)) - { - } - - Flags(Flags<BitType> const& rhs) - : m_mask(rhs.m_mask) - { - } - - explicit Flags(MaskType flags) - : m_mask(flags) - { - } - - Flags<BitType> & operator=(Flags<BitType> const& rhs) - { - m_mask = rhs.m_mask; - return *this; - } - - Flags<BitType> & operator|=(Flags<BitType> const& rhs) - { - m_mask |= rhs.m_mask; - return *this; - } - - Flags<BitType> & operator&=(Flags<BitType> const& rhs) - { - m_mask &= rhs.m_mask; - return *this; - } - - Flags<BitType> & operator^=(Flags<BitType> const& rhs) - { - m_mask ^= rhs.m_mask; - return *this; - } - - Flags<BitType> operator|(Flags<BitType> const& rhs) const - { - Flags<BitType> result(*this); - result |= rhs; - return result; - } - - Flags<BitType> operator&(Flags<BitType> const& rhs) const - { - Flags<BitType> result(*this); - result &= rhs; - return result; - } - - Flags<BitType> operator^(Flags<BitType> const& rhs) const - { - Flags<BitType> result(*this); - result ^= rhs; - return result; - } - - bool operator!() const - { - return !m_mask; - } - - Flags<BitType> operator~() const - { - Flags<BitType> result(*this); - result.m_mask ^= FlagTraits<BitType>::allFlags; - return result; - } - - bool operator==(Flags<BitType> const& rhs) const - { - return m_mask == rhs.m_mask; - } - - bool operator!=(Flags<BitType> const& rhs) const - { - return m_mask != rhs.m_mask; - } - - explicit operator bool() const - { - return !!m_mask; - } - - explicit operator MaskType() const - { - return m_mask; - } - - private: - MaskType m_mask; - }; - - template <typename BitType> - Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags) - { - return flags | bit; - } - - template <typename BitType> - Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags) - { - return flags & bit; - } - - template <typename BitType> - Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags) - { - return flags ^ bit; - } - - - template <typename RefType> - class Optional - { - public: - Optional(RefType & reference) { m_ptr = &reference; } - Optional(RefType * ptr) { m_ptr = ptr; } - Optional(std::nullptr_t) { m_ptr = nullptr; } - - operator RefType*() const { return m_ptr; } - RefType const* operator->() const { return m_ptr; } - explicit operator bool() const { return !!m_ptr; } - - private: - RefType *m_ptr; - }; - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename T> - class ArrayProxy - { - public: - ArrayProxy(std::nullptr_t) - : m_count(0) - , m_ptr(nullptr) - {} - - ArrayProxy(T & ptr) - : m_count(1) - , m_ptr(&ptr) - {} - - ArrayProxy(uint32_t count, T * ptr) - : m_count(count) - , m_ptr(ptr) - {} - - template <size_t N> - ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data) - : m_count(N) - , m_ptr(data.data()) - {} - - template <size_t N> - ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data) - : m_count(N) - , m_ptr(data.data()) - {} - - template <class Allocator = std::allocator<typename std::remove_const<T>::type>> - ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data) - : m_count(static_cast<uint32_t>(data.size())) - , m_ptr(data.data()) - {} - - template <class Allocator = std::allocator<typename std::remove_const<T>::type>> - ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data) - : m_count(static_cast<uint32_t>(data.size())) - , m_ptr(data.data()) - {} - - ArrayProxy(std::initializer_list<T> const& data) - : m_count(static_cast<uint32_t>(data.end() - data.begin())) - , m_ptr(data.begin()) - {} - - const T * begin() const - { - return m_ptr; - } - - const T * end() const - { - return m_ptr + m_count; - } - - const T & front() const - { - assert(m_count && m_ptr); - return *m_ptr; - } - - const T & back() const - { - assert(m_count && m_ptr); - return *(m_ptr + m_count - 1); - } - - bool empty() const - { - return (m_count == 0); - } - - uint32_t size() const - { - return m_count; - } - - T * data() const - { - return m_ptr; - } - - private: - uint32_t m_count; - T * m_ptr; - }; -#endif - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - - template <typename Type> class UniqueHandleTraits; - - template <typename Type> - class UniqueHandle : public UniqueHandleTraits<Type>::deleter - { - private: - using Deleter = typename UniqueHandleTraits<Type>::deleter; - public: - explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() ) - : Deleter( deleter) - , m_value( value ) - {} - - UniqueHandle( UniqueHandle const& ) = delete; - - UniqueHandle( UniqueHandle && other ) - : Deleter( std::move( static_cast<Deleter&>( other ) ) ) - , m_value( other.release() ) - {} - - ~UniqueHandle() - { - if ( m_value ) this->destroy( m_value ); - } - - UniqueHandle & operator=( UniqueHandle const& ) = delete; - - UniqueHandle & operator=( UniqueHandle && other ) - { - reset( other.release() ); - *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) ); - return *this; - } - - explicit operator bool() const - { - return m_value.operator bool(); - } - - Type const* operator->() const - { - return &m_value; - } - - Type * operator->() - { - return &m_value; - } - - Type const& operator*() const - { - return m_value; - } - - Type & operator*() - { - return m_value; - } - - const Type & get() const - { - return m_value; - } - - Type & get() - { - return m_value; - } - - void reset( Type const& value = Type() ) - { - if ( m_value != value ) - { - if ( m_value ) this->destroy( m_value ); - m_value = value; - } - } - - Type release() - { - Type value = m_value; - m_value = nullptr; - return value; - } - - void swap( UniqueHandle<Type> & rhs ) - { - std::swap(m_value, rhs.m_value); - std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs)); - } - - private: - Type m_value; - }; - - template <typename Type> - VULKAN_HPP_INLINE void swap( UniqueHandle<Type> & lhs, UniqueHandle<Type> & rhs ) - { - lhs.swap( rhs ); - } -#endif - - - template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; }; - - template <class Element> - class StructureChainElement - { - public: - explicit operator Element&() { return value; } - explicit operator const Element&() const { return value; } - private: - Element value; - }; - - template<typename ...StructureElements> - class StructureChain : private StructureChainElement<StructureElements>... - { - public: - StructureChain() - { - link<StructureElements...>(); - } - - StructureChain(StructureChain const &rhs) - { - linkAndCopy<StructureElements...>(rhs); - } - - StructureChain& operator=(StructureChain const &rhs) - { - linkAndCopy<StructureElements...>(rhs); - return *this; - } - - template<typename ClassType> ClassType& get() { return static_cast<ClassType&>(*this);} - - private: - template<typename X> - void link() - { - } - - template<typename X, typename Y, typename ...Z> - void link() - { - static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!"); - X& x = static_cast<X&>(*this); - Y& y = static_cast<Y&>(*this); - x.pNext = &y; - link<Y, Z...>(); - } - - template<typename X> - void linkAndCopy(StructureChain const &rhs) - { - static_cast<X&>(*this) = static_cast<X const &>(rhs); - } - - template<typename X, typename Y, typename ...Z> - void linkAndCopy(StructureChain const &rhs) - { - static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!"); - X& x = static_cast<X&>(*this); - Y& y = static_cast<Y&>(*this); - x = static_cast<X const &>(rhs); - x.pNext = &y; - linkAndCopy<Y, Z...>(rhs); - } - -}; - enum class Result - { - eSuccess = VK_SUCCESS, - eNotReady = VK_NOT_READY, - eTimeout = VK_TIMEOUT, - eEventSet = VK_EVENT_SET, - eEventReset = VK_EVENT_RESET, - eIncomplete = VK_INCOMPLETE, - eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY, - eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY, - eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED, - eErrorDeviceLost = VK_ERROR_DEVICE_LOST, - eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED, - eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT, - eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT, - eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT, - eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER, - eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS, - eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED, - eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL, - eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR, - eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, - eSuboptimalKHR = VK_SUBOPTIMAL_KHR, - eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR, - eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, - eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, - eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, - eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, - eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, - eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT - }; - - VULKAN_HPP_INLINE std::string to_string(Result value) - { - switch (value) - { - case Result::eSuccess: return "Success"; - case Result::eNotReady: return "NotReady"; - case Result::eTimeout: return "Timeout"; - case Result::eEventSet: return "EventSet"; - case Result::eEventReset: return "EventReset"; - case Result::eIncomplete: return "Incomplete"; - case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory"; - case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory"; - case Result::eErrorInitializationFailed: return "ErrorInitializationFailed"; - case Result::eErrorDeviceLost: return "ErrorDeviceLost"; - case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed"; - case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent"; - case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent"; - case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent"; - case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver"; - case Result::eErrorTooManyObjects: return "ErrorTooManyObjects"; - case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported"; - case Result::eErrorFragmentedPool: return "ErrorFragmentedPool"; - case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR"; - case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR"; - case Result::eSuboptimalKHR: return "SuboptimalKHR"; - case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR"; - case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR"; - case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT"; - case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV"; - case Result::eErrorOutOfPoolMemoryKHR: return "ErrorOutOfPoolMemoryKHR"; - case Result::eErrorInvalidExternalHandleKHR: return "ErrorInvalidExternalHandleKHR"; - case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT"; - default: return "invalid"; - } - } - -#ifndef VULKAN_HPP_NO_EXCEPTIONS -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# define noexcept _NOEXCEPT -#endif - - class ErrorCategoryImpl : public std::error_category - { - public: - virtual const char* name() const noexcept override { return "VULKAN_HPP_NAMESPACE::Result"; } - virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); } - }; - -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# undef noexcept -#endif - - VULKAN_HPP_INLINE const std::error_category& errorCategory() - { - static ErrorCategoryImpl instance; - return instance; - } - - VULKAN_HPP_INLINE std::error_code make_error_code(Result e) - { - return std::error_code(static_cast<int>(e), errorCategory()); - } - - VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) - { - return std::error_condition(static_cast<int>(e), errorCategory()); - } - -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# define noexcept _NOEXCEPT -#endif - - class Error - { - public: - virtual ~Error() = default; - - virtual const char* what() const noexcept = 0; - }; - - class LogicError : public Error, public std::logic_error - { - public: - explicit LogicError( const std::string& what ) - : Error(), std::logic_error(what) {} - explicit LogicError( char const * what ) - : Error(), std::logic_error(what) {} - virtual ~LogicError() = default; - - virtual const char* what() const noexcept { return std::logic_error::what(); } - }; - - class SystemError : public Error, public std::system_error - { - public: - SystemError( std::error_code ec ) - : Error(), std::system_error(ec) {} - SystemError( std::error_code ec, std::string const& what ) - : Error(), std::system_error(ec, what) {} - SystemError( std::error_code ec, char const * what ) - : Error(), std::system_error(ec, what) {} - SystemError( int ev, std::error_category const& ecat ) - : Error(), std::system_error(ev, ecat) {} - SystemError( int ev, std::error_category const& ecat, std::string const& what) - : Error(), std::system_error(ev, ecat, what) {} - SystemError( int ev, std::error_category const& ecat, char const * what) - : Error(), std::system_error(ev, ecat, what) {} - virtual ~SystemError() = default; - - virtual const char* what() const noexcept { return std::system_error::what(); } - }; - -#if defined(_MSC_VER) && (_MSC_VER == 1800) -# undef noexcept -#endif - - class OutOfHostMemoryError : public SystemError - { - public: - OutOfHostMemoryError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} - OutOfHostMemoryError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} - }; - class OutOfDeviceMemoryError : public SystemError - { - public: - OutOfDeviceMemoryError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} - OutOfDeviceMemoryError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} - }; - class InitializationFailedError : public SystemError - { - public: - InitializationFailedError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} - InitializationFailedError( char const * message ) - : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} - }; - class DeviceLostError : public SystemError - { - public: - DeviceLostError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} - DeviceLostError( char const * message ) - : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} - }; - class MemoryMapFailedError : public SystemError - { - public: - MemoryMapFailedError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} - MemoryMapFailedError( char const * message ) - : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} - }; - class LayerNotPresentError : public SystemError - { - public: - LayerNotPresentError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} - LayerNotPresentError( char const * message ) - : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} - }; - class ExtensionNotPresentError : public SystemError - { - public: - ExtensionNotPresentError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} - ExtensionNotPresentError( char const * message ) - : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} - }; - class FeatureNotPresentError : public SystemError - { - public: - FeatureNotPresentError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} - FeatureNotPresentError( char const * message ) - : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} - }; - class IncompatibleDriverError : public SystemError - { - public: - IncompatibleDriverError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} - IncompatibleDriverError( char const * message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} - }; - class TooManyObjectsError : public SystemError - { - public: - TooManyObjectsError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} - TooManyObjectsError( char const * message ) - : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} - }; - class FormatNotSupportedError : public SystemError - { - public: - FormatNotSupportedError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} - FormatNotSupportedError( char const * message ) - : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} - }; - class FragmentedPoolError : public SystemError - { - public: - FragmentedPoolError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} - FragmentedPoolError( char const * message ) - : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} - }; - class SurfaceLostKHRError : public SystemError - { - public: - SurfaceLostKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} - SurfaceLostKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} - }; - class NativeWindowInUseKHRError : public SystemError - { - public: - NativeWindowInUseKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} - NativeWindowInUseKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} - }; - class OutOfDateKHRError : public SystemError - { - public: - OutOfDateKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} - OutOfDateKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} - }; - class IncompatibleDisplayKHRError : public SystemError - { - public: - IncompatibleDisplayKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} - IncompatibleDisplayKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} - }; - class ValidationFailedEXTError : public SystemError - { - public: - ValidationFailedEXTError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} - ValidationFailedEXTError( char const * message ) - : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} - }; - class InvalidShaderNVError : public SystemError - { - public: - InvalidShaderNVError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} - InvalidShaderNVError( char const * message ) - : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} - }; - class OutOfPoolMemoryKHRError : public SystemError - { - public: - OutOfPoolMemoryKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {} - OutOfPoolMemoryKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {} - }; - class InvalidExternalHandleKHRError : public SystemError - { - public: - InvalidExternalHandleKHRError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {} - InvalidExternalHandleKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {} - }; - class NotPermittedEXTError : public SystemError - { - public: - NotPermittedEXTError( std::string const& message ) - : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} - NotPermittedEXTError( char const * message ) - : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {} - }; - - VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) - { - switch ( result ) - { - case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError ( message ); - case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError ( message ); - case Result::eErrorInitializationFailed: throw InitializationFailedError ( message ); - case Result::eErrorDeviceLost: throw DeviceLostError ( message ); - case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError ( message ); - case Result::eErrorLayerNotPresent: throw LayerNotPresentError ( message ); - case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError ( message ); - case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError ( message ); - case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError ( message ); - case Result::eErrorTooManyObjects: throw TooManyObjectsError ( message ); - case Result::eErrorFormatNotSupported: throw FormatNotSupportedError ( message ); - case Result::eErrorFragmentedPool: throw FragmentedPoolError ( message ); - case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError ( message ); - case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError ( message ); - case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError ( message ); - case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message ); - case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message ); - case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message ); - case Result::eErrorOutOfPoolMemoryKHR: throw OutOfPoolMemoryKHRError ( message ); - case Result::eErrorInvalidExternalHandleKHR: throw InvalidExternalHandleKHRError ( message ); - case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message ); - default: throw SystemError( make_error_code( result ) ); - } - } -#endif -} // namespace VULKAN_HPP_NAMESPACE - -namespace std -{ - template <> - struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type - {}; -} - -namespace VULKAN_HPP_NAMESPACE -{ - - template <typename T> - struct ResultValue - { - ResultValue( Result r, T & v ) - : result( r ) - , value( v ) - {} - - ResultValue( Result r, T && v ) - : result( r ) - , value( std::move( v ) ) - {} - - Result result; - T value; - - operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); } - }; - - template <typename T> - struct ResultValueType - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - typedef ResultValue<T> type; -#else - typedef T type; -#endif - }; - - template <> - struct ResultValueType<void> - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - typedef Result type; -#else - typedef void type; -#endif - }; - - VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( result == Result::eSuccess ); - return result; -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } -#endif - } - - template <typename T> - VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( result == Result::eSuccess ); - return ResultValue<T>( result, data ); -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } - return data; -#endif - } - - VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -#else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - throwResultException( result, message ); - } -#endif - return result; - } - - template <typename T> - VULKAN_HPP_INLINE ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -#else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - throwResultException( result, message ); - } -#endif - return ResultValue<T>( result, data ); - } - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename T> - VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T>>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits<T>::deleter const& deleter ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( result == Result::eSuccess ); - return ResultValue<UniqueHandle<T>>( result, UniqueHandle<T>(data, deleter) ); -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } - return UniqueHandle<T>(data, deleter); -#endif - } -#endif - - using SampleMask = uint32_t; - - using Bool32 = uint32_t; - - using DeviceSize = uint64_t; - - enum class FramebufferCreateFlagBits - { - }; - - using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>; - - enum class QueryPoolCreateFlagBits - { - }; - - using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>; - - enum class RenderPassCreateFlagBits - { - }; - - using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>; - - enum class SamplerCreateFlagBits - { - }; - - using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>; - - enum class PipelineLayoutCreateFlagBits - { - }; - - using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>; - - enum class PipelineCacheCreateFlagBits - { - }; - - using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>; - - enum class PipelineDepthStencilStateCreateFlagBits - { - }; - - using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>; - - enum class PipelineDynamicStateCreateFlagBits - { - }; - - using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>; - - enum class PipelineColorBlendStateCreateFlagBits - { - }; - - using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>; - - enum class PipelineMultisampleStateCreateFlagBits - { - }; - - using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>; - - enum class PipelineRasterizationStateCreateFlagBits - { - }; - - using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>; - - enum class PipelineViewportStateCreateFlagBits - { - }; - - using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>; - - enum class PipelineTessellationStateCreateFlagBits - { - }; - - using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>; - - enum class PipelineInputAssemblyStateCreateFlagBits - { - }; - - using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>; - - enum class PipelineVertexInputStateCreateFlagBits - { - }; - - using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>; - - enum class PipelineShaderStageCreateFlagBits - { - }; - - using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>; - - enum class BufferViewCreateFlagBits - { - }; - - using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>; - - enum class InstanceCreateFlagBits - { - }; - - using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>; - - enum class DeviceCreateFlagBits - { - }; - - using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>; - - enum class DeviceQueueCreateFlagBits - { - }; - - using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>; - - enum class ImageViewCreateFlagBits - { - }; - - using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>; - - enum class SemaphoreCreateFlagBits - { - }; - - using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>; - - enum class ShaderModuleCreateFlagBits - { - }; - - using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>; - - enum class EventCreateFlagBits - { - }; - - using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>; - - enum class MemoryMapFlagBits - { - }; - - using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>; - - enum class DescriptorPoolResetFlagBits - { - }; - - using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>; - - enum class DescriptorUpdateTemplateCreateFlagBitsKHR - { - }; - - using DescriptorUpdateTemplateCreateFlagsKHR = Flags<DescriptorUpdateTemplateCreateFlagBitsKHR, VkDescriptorUpdateTemplateCreateFlagsKHR>; - - enum class DisplayModeCreateFlagBitsKHR - { - }; - - using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>; - - enum class DisplaySurfaceCreateFlagBitsKHR - { - }; - - using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>; - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - enum class AndroidSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - enum class MirSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - using MirSurfaceCreateFlagsKHR = Flags<MirSurfaceCreateFlagBitsKHR, VkMirSurfaceCreateFlagsKHR>; -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_VI_NN - enum class ViSurfaceCreateFlagBitsNN - { - }; -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_VI_NN - using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN, VkViSurfaceCreateFlagsNN>; -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - enum class WaylandSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - enum class Win32SurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - enum class XlibSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - enum class XcbSurfaceCreateFlagBitsKHR - { - }; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - enum class IOSSurfaceCreateFlagBitsMVK - { - }; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - enum class MacOSSurfaceCreateFlagBitsMVK - { - }; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - enum class CommandPoolTrimFlagBitsKHR - { - }; - - using CommandPoolTrimFlagsKHR = Flags<CommandPoolTrimFlagBitsKHR, VkCommandPoolTrimFlagsKHR>; - - enum class PipelineViewportSwizzleStateCreateFlagBitsNV - { - }; - - using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV>; - - enum class PipelineDiscardRectangleStateCreateFlagBitsEXT - { - }; - - using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT>; - - enum class PipelineCoverageToColorStateCreateFlagBitsNV - { - }; - - using PipelineCoverageToColorStateCreateFlagsNV = Flags<PipelineCoverageToColorStateCreateFlagBitsNV, VkPipelineCoverageToColorStateCreateFlagsNV>; - - enum class PipelineCoverageModulationStateCreateFlagBitsNV - { - }; - - using PipelineCoverageModulationStateCreateFlagsNV = Flags<PipelineCoverageModulationStateCreateFlagBitsNV, VkPipelineCoverageModulationStateCreateFlagsNV>; - - enum class ValidationCacheCreateFlagBitsEXT - { - }; - - using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT, VkValidationCacheCreateFlagsEXT>; - - enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT - { - }; - - using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT>; - - class DeviceMemory - { - public: - DeviceMemory() - : m_deviceMemory(VK_NULL_HANDLE) - {} - - DeviceMemory( std::nullptr_t ) - : m_deviceMemory(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) - : m_deviceMemory( deviceMemory ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DeviceMemory & operator=(VkDeviceMemory deviceMemory) - { - m_deviceMemory = deviceMemory; - return *this; - } -#endif - - DeviceMemory & operator=( std::nullptr_t ) - { - m_deviceMemory = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DeviceMemory const & rhs ) const - { - return m_deviceMemory == rhs.m_deviceMemory; - } - - bool operator!=(DeviceMemory const & rhs ) const - { - return m_deviceMemory != rhs.m_deviceMemory; - } - - bool operator<(DeviceMemory const & rhs ) const - { - return m_deviceMemory < rhs.m_deviceMemory; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const - { - return m_deviceMemory; - } - - explicit operator bool() const - { - return m_deviceMemory != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_deviceMemory == VK_NULL_HANDLE; - } - - private: - VkDeviceMemory m_deviceMemory; - }; - - static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); - - class CommandPool - { - public: - CommandPool() - : m_commandPool(VK_NULL_HANDLE) - {} - - CommandPool( std::nullptr_t ) - : m_commandPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) - : m_commandPool( commandPool ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandPool & operator=(VkCommandPool commandPool) - { - m_commandPool = commandPool; - return *this; - } -#endif - - CommandPool & operator=( std::nullptr_t ) - { - m_commandPool = VK_NULL_HANDLE; - return *this; - } - - bool operator==( CommandPool const & rhs ) const - { - return m_commandPool == rhs.m_commandPool; - } - - bool operator!=(CommandPool const & rhs ) const - { - return m_commandPool != rhs.m_commandPool; - } - - bool operator<(CommandPool const & rhs ) const - { - return m_commandPool < rhs.m_commandPool; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const - { - return m_commandPool; - } - - explicit operator bool() const - { - return m_commandPool != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_commandPool == VK_NULL_HANDLE; - } - - private: - VkCommandPool m_commandPool; - }; - - static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); - - class Buffer - { - public: - Buffer() - : m_buffer(VK_NULL_HANDLE) - {} - - Buffer( std::nullptr_t ) - : m_buffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) - : m_buffer( buffer ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Buffer & operator=(VkBuffer buffer) - { - m_buffer = buffer; - return *this; - } -#endif - - Buffer & operator=( std::nullptr_t ) - { - m_buffer = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Buffer const & rhs ) const - { - return m_buffer == rhs.m_buffer; - } - - bool operator!=(Buffer const & rhs ) const - { - return m_buffer != rhs.m_buffer; - } - - bool operator<(Buffer const & rhs ) const - { - return m_buffer < rhs.m_buffer; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const - { - return m_buffer; - } - - explicit operator bool() const - { - return m_buffer != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_buffer == VK_NULL_HANDLE; - } - - private: - VkBuffer m_buffer; - }; - - static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); - - class BufferView - { - public: - BufferView() - : m_bufferView(VK_NULL_HANDLE) - {} - - BufferView( std::nullptr_t ) - : m_bufferView(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) - : m_bufferView( bufferView ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - BufferView & operator=(VkBufferView bufferView) - { - m_bufferView = bufferView; - return *this; - } -#endif - - BufferView & operator=( std::nullptr_t ) - { - m_bufferView = VK_NULL_HANDLE; - return *this; - } - - bool operator==( BufferView const & rhs ) const - { - return m_bufferView == rhs.m_bufferView; - } - - bool operator!=(BufferView const & rhs ) const - { - return m_bufferView != rhs.m_bufferView; - } - - bool operator<(BufferView const & rhs ) const - { - return m_bufferView < rhs.m_bufferView; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const - { - return m_bufferView; - } - - explicit operator bool() const - { - return m_bufferView != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_bufferView == VK_NULL_HANDLE; - } - - private: - VkBufferView m_bufferView; - }; - - static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); - - class Image - { - public: - Image() - : m_image(VK_NULL_HANDLE) - {} - - Image( std::nullptr_t ) - : m_image(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) - : m_image( image ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Image & operator=(VkImage image) - { - m_image = image; - return *this; - } -#endif - - Image & operator=( std::nullptr_t ) - { - m_image = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Image const & rhs ) const - { - return m_image == rhs.m_image; - } - - bool operator!=(Image const & rhs ) const - { - return m_image != rhs.m_image; - } - - bool operator<(Image const & rhs ) const - { - return m_image < rhs.m_image; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const - { - return m_image; - } - - explicit operator bool() const - { - return m_image != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_image == VK_NULL_HANDLE; - } - - private: - VkImage m_image; - }; - - static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); - - class ImageView - { - public: - ImageView() - : m_imageView(VK_NULL_HANDLE) - {} - - ImageView( std::nullptr_t ) - : m_imageView(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) - : m_imageView( imageView ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ImageView & operator=(VkImageView imageView) - { - m_imageView = imageView; - return *this; - } -#endif - - ImageView & operator=( std::nullptr_t ) - { - m_imageView = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ImageView const & rhs ) const - { - return m_imageView == rhs.m_imageView; - } - - bool operator!=(ImageView const & rhs ) const - { - return m_imageView != rhs.m_imageView; - } - - bool operator<(ImageView const & rhs ) const - { - return m_imageView < rhs.m_imageView; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const - { - return m_imageView; - } - - explicit operator bool() const - { - return m_imageView != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_imageView == VK_NULL_HANDLE; - } - - private: - VkImageView m_imageView; - }; - - static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); - - class ShaderModule - { - public: - ShaderModule() - : m_shaderModule(VK_NULL_HANDLE) - {} - - ShaderModule( std::nullptr_t ) - : m_shaderModule(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) - : m_shaderModule( shaderModule ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ShaderModule & operator=(VkShaderModule shaderModule) - { - m_shaderModule = shaderModule; - return *this; - } -#endif - - ShaderModule & operator=( std::nullptr_t ) - { - m_shaderModule = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ShaderModule const & rhs ) const - { - return m_shaderModule == rhs.m_shaderModule; - } - - bool operator!=(ShaderModule const & rhs ) const - { - return m_shaderModule != rhs.m_shaderModule; - } - - bool operator<(ShaderModule const & rhs ) const - { - return m_shaderModule < rhs.m_shaderModule; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const - { - return m_shaderModule; - } - - explicit operator bool() const - { - return m_shaderModule != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_shaderModule == VK_NULL_HANDLE; - } - - private: - VkShaderModule m_shaderModule; - }; - - static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); - - class Pipeline - { - public: - Pipeline() - : m_pipeline(VK_NULL_HANDLE) - {} - - Pipeline( std::nullptr_t ) - : m_pipeline(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) - : m_pipeline( pipeline ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Pipeline & operator=(VkPipeline pipeline) - { - m_pipeline = pipeline; - return *this; - } -#endif - - Pipeline & operator=( std::nullptr_t ) - { - m_pipeline = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Pipeline const & rhs ) const - { - return m_pipeline == rhs.m_pipeline; - } - - bool operator!=(Pipeline const & rhs ) const - { - return m_pipeline != rhs.m_pipeline; - } - - bool operator<(Pipeline const & rhs ) const - { - return m_pipeline < rhs.m_pipeline; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const - { - return m_pipeline; - } - - explicit operator bool() const - { - return m_pipeline != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_pipeline == VK_NULL_HANDLE; - } - - private: - VkPipeline m_pipeline; - }; - - static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); - - class PipelineLayout - { - public: - PipelineLayout() - : m_pipelineLayout(VK_NULL_HANDLE) - {} - - PipelineLayout( std::nullptr_t ) - : m_pipelineLayout(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) - : m_pipelineLayout( pipelineLayout ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineLayout & operator=(VkPipelineLayout pipelineLayout) - { - m_pipelineLayout = pipelineLayout; - return *this; - } -#endif - - PipelineLayout & operator=( std::nullptr_t ) - { - m_pipelineLayout = VK_NULL_HANDLE; - return *this; - } - - bool operator==( PipelineLayout const & rhs ) const - { - return m_pipelineLayout == rhs.m_pipelineLayout; - } - - bool operator!=(PipelineLayout const & rhs ) const - { - return m_pipelineLayout != rhs.m_pipelineLayout; - } - - bool operator<(PipelineLayout const & rhs ) const - { - return m_pipelineLayout < rhs.m_pipelineLayout; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const - { - return m_pipelineLayout; - } - - explicit operator bool() const - { - return m_pipelineLayout != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_pipelineLayout == VK_NULL_HANDLE; - } - - private: - VkPipelineLayout m_pipelineLayout; - }; - - static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); - - class Sampler - { - public: - Sampler() - : m_sampler(VK_NULL_HANDLE) - {} - - Sampler( std::nullptr_t ) - : m_sampler(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) - : m_sampler( sampler ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Sampler & operator=(VkSampler sampler) - { - m_sampler = sampler; - return *this; - } -#endif - - Sampler & operator=( std::nullptr_t ) - { - m_sampler = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Sampler const & rhs ) const - { - return m_sampler == rhs.m_sampler; - } - - bool operator!=(Sampler const & rhs ) const - { - return m_sampler != rhs.m_sampler; - } - - bool operator<(Sampler const & rhs ) const - { - return m_sampler < rhs.m_sampler; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const - { - return m_sampler; - } - - explicit operator bool() const - { - return m_sampler != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_sampler == VK_NULL_HANDLE; - } - - private: - VkSampler m_sampler; - }; - - static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); - - class DescriptorSet - { - public: - DescriptorSet() - : m_descriptorSet(VK_NULL_HANDLE) - {} - - DescriptorSet( std::nullptr_t ) - : m_descriptorSet(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) - : m_descriptorSet( descriptorSet ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSet & operator=(VkDescriptorSet descriptorSet) - { - m_descriptorSet = descriptorSet; - return *this; - } -#endif - - DescriptorSet & operator=( std::nullptr_t ) - { - m_descriptorSet = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorSet const & rhs ) const - { - return m_descriptorSet == rhs.m_descriptorSet; - } - - bool operator!=(DescriptorSet const & rhs ) const - { - return m_descriptorSet != rhs.m_descriptorSet; - } - - bool operator<(DescriptorSet const & rhs ) const - { - return m_descriptorSet < rhs.m_descriptorSet; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const - { - return m_descriptorSet; - } - - explicit operator bool() const - { - return m_descriptorSet != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorSet == VK_NULL_HANDLE; - } - - private: - VkDescriptorSet m_descriptorSet; - }; - - static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); - - class DescriptorSetLayout - { - public: - DescriptorSetLayout() - : m_descriptorSetLayout(VK_NULL_HANDLE) - {} - - DescriptorSetLayout( std::nullptr_t ) - : m_descriptorSetLayout(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) - : m_descriptorSetLayout( descriptorSetLayout ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) - { - m_descriptorSetLayout = descriptorSetLayout; - return *this; - } -#endif - - DescriptorSetLayout & operator=( std::nullptr_t ) - { - m_descriptorSetLayout = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorSetLayout const & rhs ) const - { - return m_descriptorSetLayout == rhs.m_descriptorSetLayout; - } - - bool operator!=(DescriptorSetLayout const & rhs ) const - { - return m_descriptorSetLayout != rhs.m_descriptorSetLayout; - } - - bool operator<(DescriptorSetLayout const & rhs ) const - { - return m_descriptorSetLayout < rhs.m_descriptorSetLayout; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const - { - return m_descriptorSetLayout; - } - - explicit operator bool() const - { - return m_descriptorSetLayout != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorSetLayout == VK_NULL_HANDLE; - } - - private: - VkDescriptorSetLayout m_descriptorSetLayout; - }; - - static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); - - class DescriptorPool - { - public: - DescriptorPool() - : m_descriptorPool(VK_NULL_HANDLE) - {} - - DescriptorPool( std::nullptr_t ) - : m_descriptorPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) - : m_descriptorPool( descriptorPool ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorPool & operator=(VkDescriptorPool descriptorPool) - { - m_descriptorPool = descriptorPool; - return *this; - } -#endif - - DescriptorPool & operator=( std::nullptr_t ) - { - m_descriptorPool = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorPool const & rhs ) const - { - return m_descriptorPool == rhs.m_descriptorPool; - } - - bool operator!=(DescriptorPool const & rhs ) const - { - return m_descriptorPool != rhs.m_descriptorPool; - } - - bool operator<(DescriptorPool const & rhs ) const - { - return m_descriptorPool < rhs.m_descriptorPool; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const - { - return m_descriptorPool; - } - - explicit operator bool() const - { - return m_descriptorPool != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorPool == VK_NULL_HANDLE; - } - - private: - VkDescriptorPool m_descriptorPool; - }; - - static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); - - class Fence - { - public: - Fence() - : m_fence(VK_NULL_HANDLE) - {} - - Fence( std::nullptr_t ) - : m_fence(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) - : m_fence( fence ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Fence & operator=(VkFence fence) - { - m_fence = fence; - return *this; - } -#endif - - Fence & operator=( std::nullptr_t ) - { - m_fence = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Fence const & rhs ) const - { - return m_fence == rhs.m_fence; - } - - bool operator!=(Fence const & rhs ) const - { - return m_fence != rhs.m_fence; - } - - bool operator<(Fence const & rhs ) const - { - return m_fence < rhs.m_fence; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const - { - return m_fence; - } - - explicit operator bool() const - { - return m_fence != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_fence == VK_NULL_HANDLE; - } - - private: - VkFence m_fence; - }; - - static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); - - class Semaphore - { - public: - Semaphore() - : m_semaphore(VK_NULL_HANDLE) - {} - - Semaphore( std::nullptr_t ) - : m_semaphore(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) - : m_semaphore( semaphore ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Semaphore & operator=(VkSemaphore semaphore) - { - m_semaphore = semaphore; - return *this; - } -#endif - - Semaphore & operator=( std::nullptr_t ) - { - m_semaphore = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Semaphore const & rhs ) const - { - return m_semaphore == rhs.m_semaphore; - } - - bool operator!=(Semaphore const & rhs ) const - { - return m_semaphore != rhs.m_semaphore; - } - - bool operator<(Semaphore const & rhs ) const - { - return m_semaphore < rhs.m_semaphore; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const - { - return m_semaphore; - } - - explicit operator bool() const - { - return m_semaphore != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_semaphore == VK_NULL_HANDLE; - } - - private: - VkSemaphore m_semaphore; - }; - - static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); - - class Event - { - public: - Event() - : m_event(VK_NULL_HANDLE) - {} - - Event( std::nullptr_t ) - : m_event(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) - : m_event( event ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Event & operator=(VkEvent event) - { - m_event = event; - return *this; - } -#endif - - Event & operator=( std::nullptr_t ) - { - m_event = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Event const & rhs ) const - { - return m_event == rhs.m_event; - } - - bool operator!=(Event const & rhs ) const - { - return m_event != rhs.m_event; - } - - bool operator<(Event const & rhs ) const - { - return m_event < rhs.m_event; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const - { - return m_event; - } - - explicit operator bool() const - { - return m_event != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_event == VK_NULL_HANDLE; - } - - private: - VkEvent m_event; - }; - - static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); - - class QueryPool - { - public: - QueryPool() - : m_queryPool(VK_NULL_HANDLE) - {} - - QueryPool( std::nullptr_t ) - : m_queryPool(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) - : m_queryPool( queryPool ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - QueryPool & operator=(VkQueryPool queryPool) - { - m_queryPool = queryPool; - return *this; - } -#endif - - QueryPool & operator=( std::nullptr_t ) - { - m_queryPool = VK_NULL_HANDLE; - return *this; - } - - bool operator==( QueryPool const & rhs ) const - { - return m_queryPool == rhs.m_queryPool; - } - - bool operator!=(QueryPool const & rhs ) const - { - return m_queryPool != rhs.m_queryPool; - } - - bool operator<(QueryPool const & rhs ) const - { - return m_queryPool < rhs.m_queryPool; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const - { - return m_queryPool; - } - - explicit operator bool() const - { - return m_queryPool != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_queryPool == VK_NULL_HANDLE; - } - - private: - VkQueryPool m_queryPool; - }; - - static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); - - class Framebuffer - { - public: - Framebuffer() - : m_framebuffer(VK_NULL_HANDLE) - {} - - Framebuffer( std::nullptr_t ) - : m_framebuffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) - : m_framebuffer( framebuffer ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Framebuffer & operator=(VkFramebuffer framebuffer) - { - m_framebuffer = framebuffer; - return *this; - } -#endif - - Framebuffer & operator=( std::nullptr_t ) - { - m_framebuffer = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Framebuffer const & rhs ) const - { - return m_framebuffer == rhs.m_framebuffer; - } - - bool operator!=(Framebuffer const & rhs ) const - { - return m_framebuffer != rhs.m_framebuffer; - } - - bool operator<(Framebuffer const & rhs ) const - { - return m_framebuffer < rhs.m_framebuffer; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const - { - return m_framebuffer; - } - - explicit operator bool() const - { - return m_framebuffer != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_framebuffer == VK_NULL_HANDLE; - } - - private: - VkFramebuffer m_framebuffer; - }; - - static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); - - class RenderPass - { - public: - RenderPass() - : m_renderPass(VK_NULL_HANDLE) - {} - - RenderPass( std::nullptr_t ) - : m_renderPass(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) - : m_renderPass( renderPass ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - RenderPass & operator=(VkRenderPass renderPass) - { - m_renderPass = renderPass; - return *this; - } -#endif - - RenderPass & operator=( std::nullptr_t ) - { - m_renderPass = VK_NULL_HANDLE; - return *this; - } - - bool operator==( RenderPass const & rhs ) const - { - return m_renderPass == rhs.m_renderPass; - } - - bool operator!=(RenderPass const & rhs ) const - { - return m_renderPass != rhs.m_renderPass; - } - - bool operator<(RenderPass const & rhs ) const - { - return m_renderPass < rhs.m_renderPass; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const - { - return m_renderPass; - } - - explicit operator bool() const - { - return m_renderPass != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_renderPass == VK_NULL_HANDLE; - } - - private: - VkRenderPass m_renderPass; - }; - - static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); - - class PipelineCache - { - public: - PipelineCache() - : m_pipelineCache(VK_NULL_HANDLE) - {} - - PipelineCache( std::nullptr_t ) - : m_pipelineCache(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) - : m_pipelineCache( pipelineCache ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineCache & operator=(VkPipelineCache pipelineCache) - { - m_pipelineCache = pipelineCache; - return *this; - } -#endif - - PipelineCache & operator=( std::nullptr_t ) - { - m_pipelineCache = VK_NULL_HANDLE; - return *this; - } - - bool operator==( PipelineCache const & rhs ) const - { - return m_pipelineCache == rhs.m_pipelineCache; - } - - bool operator!=(PipelineCache const & rhs ) const - { - return m_pipelineCache != rhs.m_pipelineCache; - } - - bool operator<(PipelineCache const & rhs ) const - { - return m_pipelineCache < rhs.m_pipelineCache; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const - { - return m_pipelineCache; - } - - explicit operator bool() const - { - return m_pipelineCache != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_pipelineCache == VK_NULL_HANDLE; - } - - private: - VkPipelineCache m_pipelineCache; - }; - - static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); - - class ObjectTableNVX - { - public: - ObjectTableNVX() - : m_objectTableNVX(VK_NULL_HANDLE) - {} - - ObjectTableNVX( std::nullptr_t ) - : m_objectTableNVX(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX ) - : m_objectTableNVX( objectTableNVX ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX) - { - m_objectTableNVX = objectTableNVX; - return *this; - } -#endif - - ObjectTableNVX & operator=( std::nullptr_t ) - { - m_objectTableNVX = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ObjectTableNVX const & rhs ) const - { - return m_objectTableNVX == rhs.m_objectTableNVX; - } - - bool operator!=(ObjectTableNVX const & rhs ) const - { - return m_objectTableNVX != rhs.m_objectTableNVX; - } - - bool operator<(ObjectTableNVX const & rhs ) const - { - return m_objectTableNVX < rhs.m_objectTableNVX; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const - { - return m_objectTableNVX; - } - - explicit operator bool() const - { - return m_objectTableNVX != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_objectTableNVX == VK_NULL_HANDLE; - } - - private: - VkObjectTableNVX m_objectTableNVX; - }; - - static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" ); - - class IndirectCommandsLayoutNVX - { - public: - IndirectCommandsLayoutNVX() - : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) - {} - - IndirectCommandsLayoutNVX( std::nullptr_t ) - : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX ) - : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) - { - m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX; - return *this; - } -#endif - - IndirectCommandsLayoutNVX & operator=( std::nullptr_t ) - { - m_indirectCommandsLayoutNVX = VK_NULL_HANDLE; - return *this; - } - - bool operator==( IndirectCommandsLayoutNVX const & rhs ) const - { - return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX; - } - - bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const - { - return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX; - } - - bool operator<(IndirectCommandsLayoutNVX const & rhs ) const - { - return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const - { - return m_indirectCommandsLayoutNVX; - } - - explicit operator bool() const - { - return m_indirectCommandsLayoutNVX != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_indirectCommandsLayoutNVX == VK_NULL_HANDLE; - } - - private: - VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX; - }; - - static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" ); - - class DescriptorUpdateTemplateKHR - { - public: - DescriptorUpdateTemplateKHR() - : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE) - {} - - DescriptorUpdateTemplateKHR( std::nullptr_t ) - : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR( VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR ) - : m_descriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorUpdateTemplateKHR & operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR) - { - m_descriptorUpdateTemplateKHR = descriptorUpdateTemplateKHR; - return *this; - } -#endif - - DescriptorUpdateTemplateKHR & operator=( std::nullptr_t ) - { - m_descriptorUpdateTemplateKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DescriptorUpdateTemplateKHR const & rhs ) const - { - return m_descriptorUpdateTemplateKHR == rhs.m_descriptorUpdateTemplateKHR; - } - - bool operator!=(DescriptorUpdateTemplateKHR const & rhs ) const - { - return m_descriptorUpdateTemplateKHR != rhs.m_descriptorUpdateTemplateKHR; - } - - bool operator<(DescriptorUpdateTemplateKHR const & rhs ) const - { - return m_descriptorUpdateTemplateKHR < rhs.m_descriptorUpdateTemplateKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplateKHR() const - { - return m_descriptorUpdateTemplateKHR; - } - - explicit operator bool() const - { - return m_descriptorUpdateTemplateKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_descriptorUpdateTemplateKHR == VK_NULL_HANDLE; - } - - private: - VkDescriptorUpdateTemplateKHR m_descriptorUpdateTemplateKHR; - }; - - static_assert( sizeof( DescriptorUpdateTemplateKHR ) == sizeof( VkDescriptorUpdateTemplateKHR ), "handle and wrapper have different size!" ); - - class SamplerYcbcrConversionKHR - { - public: - SamplerYcbcrConversionKHR() - : m_samplerYcbcrConversionKHR(VK_NULL_HANDLE) - {} - - SamplerYcbcrConversionKHR( std::nullptr_t ) - : m_samplerYcbcrConversionKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversionKHR( VkSamplerYcbcrConversionKHR samplerYcbcrConversionKHR ) - : m_samplerYcbcrConversionKHR( samplerYcbcrConversionKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SamplerYcbcrConversionKHR & operator=(VkSamplerYcbcrConversionKHR samplerYcbcrConversionKHR) - { - m_samplerYcbcrConversionKHR = samplerYcbcrConversionKHR; - return *this; - } -#endif - - SamplerYcbcrConversionKHR & operator=( std::nullptr_t ) - { - m_samplerYcbcrConversionKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( SamplerYcbcrConversionKHR const & rhs ) const - { - return m_samplerYcbcrConversionKHR == rhs.m_samplerYcbcrConversionKHR; - } - - bool operator!=(SamplerYcbcrConversionKHR const & rhs ) const - { - return m_samplerYcbcrConversionKHR != rhs.m_samplerYcbcrConversionKHR; - } - - bool operator<(SamplerYcbcrConversionKHR const & rhs ) const - { - return m_samplerYcbcrConversionKHR < rhs.m_samplerYcbcrConversionKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversionKHR() const - { - return m_samplerYcbcrConversionKHR; - } - - explicit operator bool() const - { - return m_samplerYcbcrConversionKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_samplerYcbcrConversionKHR == VK_NULL_HANDLE; - } - - private: - VkSamplerYcbcrConversionKHR m_samplerYcbcrConversionKHR; - }; - - static_assert( sizeof( SamplerYcbcrConversionKHR ) == sizeof( VkSamplerYcbcrConversionKHR ), "handle and wrapper have different size!" ); - - class ValidationCacheEXT - { - public: - ValidationCacheEXT() - : m_validationCacheEXT(VK_NULL_HANDLE) - {} - - ValidationCacheEXT( std::nullptr_t ) - : m_validationCacheEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) - : m_validationCacheEXT( validationCacheEXT ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT) - { - m_validationCacheEXT = validationCacheEXT; - return *this; - } -#endif - - ValidationCacheEXT & operator=( std::nullptr_t ) - { - m_validationCacheEXT = VK_NULL_HANDLE; - return *this; - } - - bool operator==( ValidationCacheEXT const & rhs ) const - { - return m_validationCacheEXT == rhs.m_validationCacheEXT; - } - - bool operator!=(ValidationCacheEXT const & rhs ) const - { - return m_validationCacheEXT != rhs.m_validationCacheEXT; - } - - bool operator<(ValidationCacheEXT const & rhs ) const - { - return m_validationCacheEXT < rhs.m_validationCacheEXT; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const - { - return m_validationCacheEXT; - } - - explicit operator bool() const - { - return m_validationCacheEXT != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_validationCacheEXT == VK_NULL_HANDLE; - } - - private: - VkValidationCacheEXT m_validationCacheEXT; - }; - - static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); - - class DisplayKHR - { - public: - DisplayKHR() - : m_displayKHR(VK_NULL_HANDLE) - {} - - DisplayKHR( std::nullptr_t ) - : m_displayKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) - : m_displayKHR( displayKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayKHR & operator=(VkDisplayKHR displayKHR) - { - m_displayKHR = displayKHR; - return *this; - } -#endif - - DisplayKHR & operator=( std::nullptr_t ) - { - m_displayKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DisplayKHR const & rhs ) const - { - return m_displayKHR == rhs.m_displayKHR; - } - - bool operator!=(DisplayKHR const & rhs ) const - { - return m_displayKHR != rhs.m_displayKHR; - } - - bool operator<(DisplayKHR const & rhs ) const - { - return m_displayKHR < rhs.m_displayKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const - { - return m_displayKHR; - } - - explicit operator bool() const - { - return m_displayKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_displayKHR == VK_NULL_HANDLE; - } - - private: - VkDisplayKHR m_displayKHR; - }; - - static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); - - class DisplayModeKHR - { - public: - DisplayModeKHR() - : m_displayModeKHR(VK_NULL_HANDLE) - {} - - DisplayModeKHR( std::nullptr_t ) - : m_displayModeKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) - : m_displayModeKHR( displayModeKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) - { - m_displayModeKHR = displayModeKHR; - return *this; - } -#endif - - DisplayModeKHR & operator=( std::nullptr_t ) - { - m_displayModeKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DisplayModeKHR const & rhs ) const - { - return m_displayModeKHR == rhs.m_displayModeKHR; - } - - bool operator!=(DisplayModeKHR const & rhs ) const - { - return m_displayModeKHR != rhs.m_displayModeKHR; - } - - bool operator<(DisplayModeKHR const & rhs ) const - { - return m_displayModeKHR < rhs.m_displayModeKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const - { - return m_displayModeKHR; - } - - explicit operator bool() const - { - return m_displayModeKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_displayModeKHR == VK_NULL_HANDLE; - } - - private: - VkDisplayModeKHR m_displayModeKHR; - }; - - static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); - - class SurfaceKHR - { - public: - SurfaceKHR() - : m_surfaceKHR(VK_NULL_HANDLE) - {} - - SurfaceKHR( std::nullptr_t ) - : m_surfaceKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) - : m_surfaceKHR( surfaceKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) - { - m_surfaceKHR = surfaceKHR; - return *this; - } -#endif - - SurfaceKHR & operator=( std::nullptr_t ) - { - m_surfaceKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( SurfaceKHR const & rhs ) const - { - return m_surfaceKHR == rhs.m_surfaceKHR; - } - - bool operator!=(SurfaceKHR const & rhs ) const - { - return m_surfaceKHR != rhs.m_surfaceKHR; - } - - bool operator<(SurfaceKHR const & rhs ) const - { - return m_surfaceKHR < rhs.m_surfaceKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const - { - return m_surfaceKHR; - } - - explicit operator bool() const - { - return m_surfaceKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_surfaceKHR == VK_NULL_HANDLE; - } - - private: - VkSurfaceKHR m_surfaceKHR; - }; - - static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); - - class SwapchainKHR - { - public: - SwapchainKHR() - : m_swapchainKHR(VK_NULL_HANDLE) - {} - - SwapchainKHR( std::nullptr_t ) - : m_swapchainKHR(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) - : m_swapchainKHR( swapchainKHR ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) - { - m_swapchainKHR = swapchainKHR; - return *this; - } -#endif - - SwapchainKHR & operator=( std::nullptr_t ) - { - m_swapchainKHR = VK_NULL_HANDLE; - return *this; - } - - bool operator==( SwapchainKHR const & rhs ) const - { - return m_swapchainKHR == rhs.m_swapchainKHR; - } - - bool operator!=(SwapchainKHR const & rhs ) const - { - return m_swapchainKHR != rhs.m_swapchainKHR; - } - - bool operator<(SwapchainKHR const & rhs ) const - { - return m_swapchainKHR < rhs.m_swapchainKHR; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const - { - return m_swapchainKHR; - } - - explicit operator bool() const - { - return m_swapchainKHR != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_swapchainKHR == VK_NULL_HANDLE; - } - - private: - VkSwapchainKHR m_swapchainKHR; - }; - - static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); - - class DebugReportCallbackEXT - { - public: - DebugReportCallbackEXT() - : m_debugReportCallbackEXT(VK_NULL_HANDLE) - {} - - DebugReportCallbackEXT( std::nullptr_t ) - : m_debugReportCallbackEXT(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) - : m_debugReportCallbackEXT( debugReportCallbackEXT ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) - { - m_debugReportCallbackEXT = debugReportCallbackEXT; - return *this; - } -#endif - - DebugReportCallbackEXT & operator=( std::nullptr_t ) - { - m_debugReportCallbackEXT = VK_NULL_HANDLE; - return *this; - } - - bool operator==( DebugReportCallbackEXT const & rhs ) const - { - return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT; - } - - bool operator!=(DebugReportCallbackEXT const & rhs ) const - { - return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT; - } - - bool operator<(DebugReportCallbackEXT const & rhs ) const - { - return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT; - } - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const - { - return m_debugReportCallbackEXT; - } - - explicit operator bool() const - { - return m_debugReportCallbackEXT != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_debugReportCallbackEXT == VK_NULL_HANDLE; - } - - private: - VkDebugReportCallbackEXT m_debugReportCallbackEXT; - }; - - static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); - - struct Offset2D - { - Offset2D( int32_t x_ = 0, int32_t y_ = 0 ) - : x( x_ ) - , y( y_ ) - { - } - - Offset2D( VkOffset2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset2D ) ); - } - - Offset2D& operator=( VkOffset2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset2D ) ); - return *this; - } - Offset2D& setX( int32_t x_ ) - { - x = x_; - return *this; - } - - Offset2D& setY( int32_t y_ ) - { - y = y_; - return *this; - } - - operator const VkOffset2D&() const - { - return *reinterpret_cast<const VkOffset2D*>(this); - } - - bool operator==( Offset2D const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ); - } - - bool operator!=( Offset2D const& rhs ) const - { - return !operator==( rhs ); - } - - int32_t x; - int32_t y; - }; - static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" ); - - struct Offset3D - { - Offset3D( int32_t x_ = 0, int32_t y_ = 0, int32_t z_ = 0 ) - : x( x_ ) - , y( y_ ) - , z( z_ ) - { - } - - Offset3D( VkOffset3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset3D ) ); - } - - Offset3D& operator=( VkOffset3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Offset3D ) ); - return *this; - } - Offset3D& setX( int32_t x_ ) - { - x = x_; - return *this; - } - - Offset3D& setY( int32_t y_ ) - { - y = y_; - return *this; - } - - Offset3D& setZ( int32_t z_ ) - { - z = z_; - return *this; - } - - operator const VkOffset3D&() const - { - return *reinterpret_cast<const VkOffset3D*>(this); - } - - bool operator==( Offset3D const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( z == rhs.z ); - } - - bool operator!=( Offset3D const& rhs ) const - { - return !operator==( rhs ); - } - - int32_t x; - int32_t y; - int32_t z; - }; - static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" ); - - struct Extent2D - { - Extent2D( uint32_t width_ = 0, uint32_t height_ = 0 ) - : width( width_ ) - , height( height_ ) - { - } - - Extent2D( VkExtent2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent2D ) ); - } - - Extent2D& operator=( VkExtent2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent2D ) ); - return *this; - } - Extent2D& setWidth( uint32_t width_ ) - { - width = width_; - return *this; - } - - Extent2D& setHeight( uint32_t height_ ) - { - height = height_; - return *this; - } - - operator const VkExtent2D&() const - { - return *reinterpret_cast<const VkExtent2D*>(this); - } - - bool operator==( Extent2D const& rhs ) const - { - return ( width == rhs.width ) - && ( height == rhs.height ); - } - - bool operator!=( Extent2D const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t width; - uint32_t height; - }; - static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" ); - - struct Extent3D - { - Extent3D( uint32_t width_ = 0, uint32_t height_ = 0, uint32_t depth_ = 0 ) - : width( width_ ) - , height( height_ ) - , depth( depth_ ) - { - } - - Extent3D( VkExtent3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent3D ) ); - } - - Extent3D& operator=( VkExtent3D const & rhs ) - { - memcpy( this, &rhs, sizeof( Extent3D ) ); - return *this; - } - Extent3D& setWidth( uint32_t width_ ) - { - width = width_; - return *this; - } - - Extent3D& setHeight( uint32_t height_ ) - { - height = height_; - return *this; - } - - Extent3D& setDepth( uint32_t depth_ ) - { - depth = depth_; - return *this; - } - - operator const VkExtent3D&() const - { - return *reinterpret_cast<const VkExtent3D*>(this); - } - - bool operator==( Extent3D const& rhs ) const - { - return ( width == rhs.width ) - && ( height == rhs.height ) - && ( depth == rhs.depth ); - } - - bool operator!=( Extent3D const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t width; - uint32_t height; - uint32_t depth; - }; - static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" ); - - struct Viewport - { - Viewport( float x_ = 0, float y_ = 0, float width_ = 0, float height_ = 0, float minDepth_ = 0, float maxDepth_ = 0 ) - : x( x_ ) - , y( y_ ) - , width( width_ ) - , height( height_ ) - , minDepth( minDepth_ ) - , maxDepth( maxDepth_ ) - { - } - - Viewport( VkViewport const & rhs ) - { - memcpy( this, &rhs, sizeof( Viewport ) ); - } - - Viewport& operator=( VkViewport const & rhs ) - { - memcpy( this, &rhs, sizeof( Viewport ) ); - return *this; - } - Viewport& setX( float x_ ) - { - x = x_; - return *this; - } - - Viewport& setY( float y_ ) - { - y = y_; - return *this; - } - - Viewport& setWidth( float width_ ) - { - width = width_; - return *this; - } - - Viewport& setHeight( float height_ ) - { - height = height_; - return *this; - } - - Viewport& setMinDepth( float minDepth_ ) - { - minDepth = minDepth_; - return *this; - } - - Viewport& setMaxDepth( float maxDepth_ ) - { - maxDepth = maxDepth_; - return *this; - } - - operator const VkViewport&() const - { - return *reinterpret_cast<const VkViewport*>(this); - } - - bool operator==( Viewport const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( width == rhs.width ) - && ( height == rhs.height ) - && ( minDepth == rhs.minDepth ) - && ( maxDepth == rhs.maxDepth ); - } - - bool operator!=( Viewport const& rhs ) const - { - return !operator==( rhs ); - } - - float x; - float y; - float width; - float height; - float minDepth; - float maxDepth; - }; - static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); - - struct Rect2D - { - Rect2D( Offset2D offset_ = Offset2D(), Extent2D extent_ = Extent2D() ) - : offset( offset_ ) - , extent( extent_ ) - { - } - - Rect2D( VkRect2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Rect2D ) ); - } - - Rect2D& operator=( VkRect2D const & rhs ) - { - memcpy( this, &rhs, sizeof( Rect2D ) ); - return *this; - } - Rect2D& setOffset( Offset2D offset_ ) - { - offset = offset_; - return *this; - } - - Rect2D& setExtent( Extent2D extent_ ) - { - extent = extent_; - return *this; - } - - operator const VkRect2D&() const - { - return *reinterpret_cast<const VkRect2D*>(this); - } - - bool operator==( Rect2D const& rhs ) const - { - return ( offset == rhs.offset ) - && ( extent == rhs.extent ); - } - - bool operator!=( Rect2D const& rhs ) const - { - return !operator==( rhs ); - } - - Offset2D offset; - Extent2D extent; - }; - static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); - - struct ClearRect - { - ClearRect( Rect2D rect_ = Rect2D(), uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 ) - : rect( rect_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } - - ClearRect( VkClearRect const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearRect ) ); - } - - ClearRect& operator=( VkClearRect const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearRect ) ); - return *this; - } - ClearRect& setRect( Rect2D rect_ ) - { - rect = rect_; - return *this; - } - - ClearRect& setBaseArrayLayer( uint32_t baseArrayLayer_ ) - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - ClearRect& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } - - operator const VkClearRect&() const - { - return *reinterpret_cast<const VkClearRect*>(this); - } - - bool operator==( ClearRect const& rhs ) const - { - return ( rect == rhs.rect ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } - - bool operator!=( ClearRect const& rhs ) const - { - return !operator==( rhs ); - } - - Rect2D rect; - uint32_t baseArrayLayer; - uint32_t layerCount; - }; - static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" ); - - struct ExtensionProperties - { - operator const VkExtensionProperties&() const - { - return *reinterpret_cast<const VkExtensionProperties*>(this); - } - - bool operator==( ExtensionProperties const& rhs ) const - { - return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 ) - && ( specVersion == rhs.specVersion ); - } - - bool operator!=( ExtensionProperties const& rhs ) const - { - return !operator==( rhs ); - } - - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - }; - static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" ); - - struct LayerProperties - { - operator const VkLayerProperties&() const - { - return *reinterpret_cast<const VkLayerProperties*>(this); - } - - bool operator==( LayerProperties const& rhs ) const - { - return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 ) - && ( specVersion == rhs.specVersion ) - && ( implementationVersion == rhs.implementationVersion ) - && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ); - } - - bool operator!=( LayerProperties const& rhs ) const - { - return !operator==( rhs ); - } - - char layerName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - uint32_t implementationVersion; - char description[VK_MAX_DESCRIPTION_SIZE]; - }; - static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" ); - - struct AllocationCallbacks - { - AllocationCallbacks( void* pUserData_ = nullptr, PFN_vkAllocationFunction pfnAllocation_ = nullptr, PFN_vkReallocationFunction pfnReallocation_ = nullptr, PFN_vkFreeFunction pfnFree_ = nullptr, PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr, PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr ) - : pUserData( pUserData_ ) - , pfnAllocation( pfnAllocation_ ) - , pfnReallocation( pfnReallocation_ ) - , pfnFree( pfnFree_ ) - , pfnInternalAllocation( pfnInternalAllocation_ ) - , pfnInternalFree( pfnInternalFree_ ) - { - } - - AllocationCallbacks( VkAllocationCallbacks const & rhs ) - { - memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); - } - - AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) - { - memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); - return *this; - } - AllocationCallbacks& setPUserData( void* pUserData_ ) - { - pUserData = pUserData_; - return *this; - } - - AllocationCallbacks& setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) - { - pfnAllocation = pfnAllocation_; - return *this; - } - - AllocationCallbacks& setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) - { - pfnReallocation = pfnReallocation_; - return *this; - } - - AllocationCallbacks& setPfnFree( PFN_vkFreeFunction pfnFree_ ) - { - pfnFree = pfnFree_; - return *this; - } - - AllocationCallbacks& setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) - { - pfnInternalAllocation = pfnInternalAllocation_; - return *this; - } - - AllocationCallbacks& setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) - { - pfnInternalFree = pfnInternalFree_; - return *this; - } - - operator const VkAllocationCallbacks&() const - { - return *reinterpret_cast<const VkAllocationCallbacks*>(this); - } - - bool operator==( AllocationCallbacks const& rhs ) const - { - return ( pUserData == rhs.pUserData ) - && ( pfnAllocation == rhs.pfnAllocation ) - && ( pfnReallocation == rhs.pfnReallocation ) - && ( pfnFree == rhs.pfnFree ) - && ( pfnInternalAllocation == rhs.pfnInternalAllocation ) - && ( pfnInternalFree == rhs.pfnInternalFree ); - } - - bool operator!=( AllocationCallbacks const& rhs ) const - { - return !operator==( rhs ); - } - - void* pUserData; - PFN_vkAllocationFunction pfnAllocation; - PFN_vkReallocationFunction pfnReallocation; - PFN_vkFreeFunction pfnFree; - PFN_vkInternalAllocationNotification pfnInternalAllocation; - PFN_vkInternalFreeNotification pfnInternalFree; - }; - static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" ); - - struct MemoryRequirements - { - operator const VkMemoryRequirements&() const - { - return *reinterpret_cast<const VkMemoryRequirements*>(this); - } - - bool operator==( MemoryRequirements const& rhs ) const - { - return ( size == rhs.size ) - && ( alignment == rhs.alignment ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryRequirements const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize size; - DeviceSize alignment; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); - - struct DescriptorBufferInfo - { - DescriptorBufferInfo( Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize range_ = 0 ) - : buffer( buffer_ ) - , offset( offset_ ) - , range( range_ ) - { - } - - DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); - } - - DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); - return *this; - } - DescriptorBufferInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - DescriptorBufferInfo& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - DescriptorBufferInfo& setRange( DeviceSize range_ ) - { - range = range_; - return *this; - } - - operator const VkDescriptorBufferInfo&() const - { - return *reinterpret_cast<const VkDescriptorBufferInfo*>(this); - } - - bool operator==( DescriptorBufferInfo const& rhs ) const - { - return ( buffer == rhs.buffer ) - && ( offset == rhs.offset ) - && ( range == rhs.range ); - } - - bool operator!=( DescriptorBufferInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Buffer buffer; - DeviceSize offset; - DeviceSize range; - }; - static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" ); - - struct SubresourceLayout - { - operator const VkSubresourceLayout&() const - { - return *reinterpret_cast<const VkSubresourceLayout*>(this); - } - - bool operator==( SubresourceLayout const& rhs ) const - { - return ( offset == rhs.offset ) - && ( size == rhs.size ) - && ( rowPitch == rhs.rowPitch ) - && ( arrayPitch == rhs.arrayPitch ) - && ( depthPitch == rhs.depthPitch ); - } - - bool operator!=( SubresourceLayout const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize offset; - DeviceSize size; - DeviceSize rowPitch; - DeviceSize arrayPitch; - DeviceSize depthPitch; - }; - static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); - - struct BufferCopy - { - BufferCopy( DeviceSize srcOffset_ = 0, DeviceSize dstOffset_ = 0, DeviceSize size_ = 0 ) - : srcOffset( srcOffset_ ) - , dstOffset( dstOffset_ ) - , size( size_ ) - { - } - - BufferCopy( VkBufferCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCopy ) ); - } - - BufferCopy& operator=( VkBufferCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCopy ) ); - return *this; - } - BufferCopy& setSrcOffset( DeviceSize srcOffset_ ) - { - srcOffset = srcOffset_; - return *this; - } - - BufferCopy& setDstOffset( DeviceSize dstOffset_ ) - { - dstOffset = dstOffset_; - return *this; - } - - BufferCopy& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - operator const VkBufferCopy&() const - { - return *reinterpret_cast<const VkBufferCopy*>(this); - } - - bool operator==( BufferCopy const& rhs ) const - { - return ( srcOffset == rhs.srcOffset ) - && ( dstOffset == rhs.dstOffset ) - && ( size == rhs.size ); - } - - bool operator!=( BufferCopy const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize srcOffset; - DeviceSize dstOffset; - DeviceSize size; - }; - static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); - - struct SpecializationMapEntry - { - SpecializationMapEntry( uint32_t constantID_ = 0, uint32_t offset_ = 0, size_t size_ = 0 ) - : constantID( constantID_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); - } - - SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); - return *this; - } - SpecializationMapEntry& setConstantID( uint32_t constantID_ ) - { - constantID = constantID_; - return *this; - } - - SpecializationMapEntry& setOffset( uint32_t offset_ ) - { - offset = offset_; - return *this; - } - - SpecializationMapEntry& setSize( size_t size_ ) - { - size = size_; - return *this; - } - - operator const VkSpecializationMapEntry&() const - { - return *reinterpret_cast<const VkSpecializationMapEntry*>(this); - } - - bool operator==( SpecializationMapEntry const& rhs ) const - { - return ( constantID == rhs.constantID ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( SpecializationMapEntry const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t constantID; - uint32_t offset; - size_t size; - }; - static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" ); - - struct SpecializationInfo - { - SpecializationInfo( uint32_t mapEntryCount_ = 0, const SpecializationMapEntry* pMapEntries_ = nullptr, size_t dataSize_ = 0, const void* pData_ = nullptr ) - : mapEntryCount( mapEntryCount_ ) - , pMapEntries( pMapEntries_ ) - , dataSize( dataSize_ ) - , pData( pData_ ) - { - } - - SpecializationInfo( VkSpecializationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationInfo ) ); - } - - SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SpecializationInfo ) ); - return *this; - } - SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ ) - { - mapEntryCount = mapEntryCount_; - return *this; - } - - SpecializationInfo& setPMapEntries( const SpecializationMapEntry* pMapEntries_ ) - { - pMapEntries = pMapEntries_; - return *this; - } - - SpecializationInfo& setDataSize( size_t dataSize_ ) - { - dataSize = dataSize_; - return *this; - } - - SpecializationInfo& setPData( const void* pData_ ) - { - pData = pData_; - return *this; - } - - operator const VkSpecializationInfo&() const - { - return *reinterpret_cast<const VkSpecializationInfo*>(this); - } - - bool operator==( SpecializationInfo const& rhs ) const - { - return ( mapEntryCount == rhs.mapEntryCount ) - && ( pMapEntries == rhs.pMapEntries ) - && ( dataSize == rhs.dataSize ) - && ( pData == rhs.pData ); - } - - bool operator!=( SpecializationInfo const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t mapEntryCount; - const SpecializationMapEntry* pMapEntries; - size_t dataSize; - const void* pData; - }; - static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); - - union ClearColorValue - { - ClearColorValue( const std::array<float,4>& float32_ = { {0} } ) - { - memcpy( &float32, float32_.data(), 4 * sizeof( float ) ); - } - - ClearColorValue( const std::array<int32_t,4>& int32_ ) - { - memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) ); - } - - ClearColorValue( const std::array<uint32_t,4>& uint32_ ) - { - memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) ); - } - - ClearColorValue& setFloat32( std::array<float,4> float32_ ) - { - memcpy( &float32, float32_.data(), 4 * sizeof( float ) ); - return *this; - } - - ClearColorValue& setInt32( std::array<int32_t,4> int32_ ) - { - memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) ); - return *this; - } - - ClearColorValue& setUint32( std::array<uint32_t,4> uint32_ ) - { - memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) ); - return *this; - } - - operator VkClearColorValue const& () const - { - return *reinterpret_cast<const VkClearColorValue*>(this); - } - - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; - }; - - struct ClearDepthStencilValue - { - ClearDepthStencilValue( float depth_ = 0, uint32_t stencil_ = 0 ) - : depth( depth_ ) - , stencil( stencil_ ) - { - } - - ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); - } - - ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); - return *this; - } - ClearDepthStencilValue& setDepth( float depth_ ) - { - depth = depth_; - return *this; - } - - ClearDepthStencilValue& setStencil( uint32_t stencil_ ) - { - stencil = stencil_; - return *this; - } - - operator const VkClearDepthStencilValue&() const - { - return *reinterpret_cast<const VkClearDepthStencilValue*>(this); - } - - bool operator==( ClearDepthStencilValue const& rhs ) const - { - return ( depth == rhs.depth ) - && ( stencil == rhs.stencil ); - } - - bool operator!=( ClearDepthStencilValue const& rhs ) const - { - return !operator==( rhs ); - } - - float depth; - uint32_t stencil; - }; - static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" ); - - union ClearValue - { - ClearValue( ClearColorValue color_ = ClearColorValue() ) - { - color = color_; - } - - ClearValue( ClearDepthStencilValue depthStencil_ ) - { - depthStencil = depthStencil_; - } - - ClearValue& setColor( ClearColorValue color_ ) - { - color = color_; - return *this; - } - - ClearValue& setDepthStencil( ClearDepthStencilValue depthStencil_ ) - { - depthStencil = depthStencil_; - return *this; - } - - operator VkClearValue const& () const - { - return *reinterpret_cast<const VkClearValue*>(this); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - ClearColorValue color; - ClearDepthStencilValue depthStencil; -#else - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -#endif // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - }; - - struct PhysicalDeviceFeatures - { - 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 ) - : robustBufferAccess( robustBufferAccess_ ) - , fullDrawIndexUint32( fullDrawIndexUint32_ ) - , imageCubeArray( imageCubeArray_ ) - , independentBlend( independentBlend_ ) - , geometryShader( geometryShader_ ) - , tessellationShader( tessellationShader_ ) - , sampleRateShading( sampleRateShading_ ) - , dualSrcBlend( dualSrcBlend_ ) - , logicOp( logicOp_ ) - , multiDrawIndirect( multiDrawIndirect_ ) - , drawIndirectFirstInstance( drawIndirectFirstInstance_ ) - , depthClamp( depthClamp_ ) - , depthBiasClamp( depthBiasClamp_ ) - , fillModeNonSolid( fillModeNonSolid_ ) - , depthBounds( depthBounds_ ) - , wideLines( wideLines_ ) - , largePoints( largePoints_ ) - , alphaToOne( alphaToOne_ ) - , multiViewport( multiViewport_ ) - , samplerAnisotropy( samplerAnisotropy_ ) - , textureCompressionETC2( textureCompressionETC2_ ) - , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ ) - , textureCompressionBC( textureCompressionBC_ ) - , occlusionQueryPrecise( occlusionQueryPrecise_ ) - , pipelineStatisticsQuery( pipelineStatisticsQuery_ ) - , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ ) - , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ ) - , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ ) - , shaderImageGatherExtended( shaderImageGatherExtended_ ) - , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ ) - , shaderStorageImageMultisample( shaderStorageImageMultisample_ ) - , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ ) - , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ ) - , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ ) - , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ ) - , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ ) - , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ ) - , shaderClipDistance( shaderClipDistance_ ) - , shaderCullDistance( shaderCullDistance_ ) - , shaderFloat64( shaderFloat64_ ) - , shaderInt64( shaderInt64_ ) - , shaderInt16( shaderInt16_ ) - , shaderResourceResidency( shaderResourceResidency_ ) - , shaderResourceMinLod( shaderResourceMinLod_ ) - , sparseBinding( sparseBinding_ ) - , sparseResidencyBuffer( sparseResidencyBuffer_ ) - , sparseResidencyImage2D( sparseResidencyImage2D_ ) - , sparseResidencyImage3D( sparseResidencyImage3D_ ) - , sparseResidency2Samples( sparseResidency2Samples_ ) - , sparseResidency4Samples( sparseResidency4Samples_ ) - , sparseResidency8Samples( sparseResidency8Samples_ ) - , sparseResidency16Samples( sparseResidency16Samples_ ) - , sparseResidencyAliased( sparseResidencyAliased_ ) - , variableMultisampleRate( variableMultisampleRate_ ) - , inheritedQueries( inheritedQueries_ ) - { - } - - PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); - } - - PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); - return *this; - } - PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ ) - { - robustBufferAccess = robustBufferAccess_; - return *this; - } - - PhysicalDeviceFeatures& setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) - { - fullDrawIndexUint32 = fullDrawIndexUint32_; - return *this; - } - - PhysicalDeviceFeatures& setImageCubeArray( Bool32 imageCubeArray_ ) - { - imageCubeArray = imageCubeArray_; - return *this; - } - - PhysicalDeviceFeatures& setIndependentBlend( Bool32 independentBlend_ ) - { - independentBlend = independentBlend_; - return *this; - } - - PhysicalDeviceFeatures& setGeometryShader( Bool32 geometryShader_ ) - { - geometryShader = geometryShader_; - return *this; - } - - PhysicalDeviceFeatures& setTessellationShader( Bool32 tessellationShader_ ) - { - tessellationShader = tessellationShader_; - return *this; - } - - PhysicalDeviceFeatures& setSampleRateShading( Bool32 sampleRateShading_ ) - { - sampleRateShading = sampleRateShading_; - return *this; - } - - PhysicalDeviceFeatures& setDualSrcBlend( Bool32 dualSrcBlend_ ) - { - dualSrcBlend = dualSrcBlend_; - return *this; - } - - PhysicalDeviceFeatures& setLogicOp( Bool32 logicOp_ ) - { - logicOp = logicOp_; - return *this; - } - - PhysicalDeviceFeatures& setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) - { - multiDrawIndirect = multiDrawIndirect_; - return *this; - } - - PhysicalDeviceFeatures& setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) - { - drawIndirectFirstInstance = drawIndirectFirstInstance_; - return *this; - } - - PhysicalDeviceFeatures& setDepthClamp( Bool32 depthClamp_ ) - { - depthClamp = depthClamp_; - return *this; - } - - PhysicalDeviceFeatures& setDepthBiasClamp( Bool32 depthBiasClamp_ ) - { - depthBiasClamp = depthBiasClamp_; - return *this; - } - - PhysicalDeviceFeatures& setFillModeNonSolid( Bool32 fillModeNonSolid_ ) - { - fillModeNonSolid = fillModeNonSolid_; - return *this; - } - - PhysicalDeviceFeatures& setDepthBounds( Bool32 depthBounds_ ) - { - depthBounds = depthBounds_; - return *this; - } - - PhysicalDeviceFeatures& setWideLines( Bool32 wideLines_ ) - { - wideLines = wideLines_; - return *this; - } - - PhysicalDeviceFeatures& setLargePoints( Bool32 largePoints_ ) - { - largePoints = largePoints_; - return *this; - } - - PhysicalDeviceFeatures& setAlphaToOne( Bool32 alphaToOne_ ) - { - alphaToOne = alphaToOne_; - return *this; - } - - PhysicalDeviceFeatures& setMultiViewport( Bool32 multiViewport_ ) - { - multiViewport = multiViewport_; - return *this; - } - - PhysicalDeviceFeatures& setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) - { - samplerAnisotropy = samplerAnisotropy_; - return *this; - } - - PhysicalDeviceFeatures& setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) - { - textureCompressionETC2 = textureCompressionETC2_; - return *this; - } - - PhysicalDeviceFeatures& setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) - { - textureCompressionASTC_LDR = textureCompressionASTC_LDR_; - return *this; - } - - PhysicalDeviceFeatures& setTextureCompressionBC( Bool32 textureCompressionBC_ ) - { - textureCompressionBC = textureCompressionBC_; - return *this; - } - - PhysicalDeviceFeatures& setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) - { - occlusionQueryPrecise = occlusionQueryPrecise_; - return *this; - } - - PhysicalDeviceFeatures& setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) - { - pipelineStatisticsQuery = pipelineStatisticsQuery_; - return *this; - } - - PhysicalDeviceFeatures& setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) - { - vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_; - return *this; - } - - PhysicalDeviceFeatures& setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) - { - fragmentStoresAndAtomics = fragmentStoresAndAtomics_; - return *this; - } - - PhysicalDeviceFeatures& setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) - { - shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_; - return *this; - } - - PhysicalDeviceFeatures& setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) - { - shaderImageGatherExtended = shaderImageGatherExtended_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) - { - shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ ) - { - shaderStorageImageMultisample = shaderStorageImageMultisample_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ ) - { - shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ ) - { - shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_; - return *this; - } - - PhysicalDeviceFeatures& setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ ) - { - shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ ) - { - shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ ) - { - shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ ) - { - shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_; - return *this; - } - - PhysicalDeviceFeatures& setShaderClipDistance( Bool32 shaderClipDistance_ ) - { - shaderClipDistance = shaderClipDistance_; - return *this; - } - - PhysicalDeviceFeatures& setShaderCullDistance( Bool32 shaderCullDistance_ ) - { - shaderCullDistance = shaderCullDistance_; - return *this; - } - - PhysicalDeviceFeatures& setShaderFloat64( Bool32 shaderFloat64_ ) - { - shaderFloat64 = shaderFloat64_; - return *this; - } - - PhysicalDeviceFeatures& setShaderInt64( Bool32 shaderInt64_ ) - { - shaderInt64 = shaderInt64_; - return *this; - } - - PhysicalDeviceFeatures& setShaderInt16( Bool32 shaderInt16_ ) - { - shaderInt16 = shaderInt16_; - return *this; - } - - PhysicalDeviceFeatures& setShaderResourceResidency( Bool32 shaderResourceResidency_ ) - { - shaderResourceResidency = shaderResourceResidency_; - return *this; - } - - PhysicalDeviceFeatures& setShaderResourceMinLod( Bool32 shaderResourceMinLod_ ) - { - shaderResourceMinLod = shaderResourceMinLod_; - return *this; - } - - PhysicalDeviceFeatures& setSparseBinding( Bool32 sparseBinding_ ) - { - sparseBinding = sparseBinding_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ ) - { - sparseResidencyBuffer = sparseResidencyBuffer_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ ) - { - sparseResidencyImage2D = sparseResidencyImage2D_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ ) - { - sparseResidencyImage3D = sparseResidencyImage3D_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency2Samples( Bool32 sparseResidency2Samples_ ) - { - sparseResidency2Samples = sparseResidency2Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency4Samples( Bool32 sparseResidency4Samples_ ) - { - sparseResidency4Samples = sparseResidency4Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency8Samples( Bool32 sparseResidency8Samples_ ) - { - sparseResidency8Samples = sparseResidency8Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidency16Samples( Bool32 sparseResidency16Samples_ ) - { - sparseResidency16Samples = sparseResidency16Samples_; - return *this; - } - - PhysicalDeviceFeatures& setSparseResidencyAliased( Bool32 sparseResidencyAliased_ ) - { - sparseResidencyAliased = sparseResidencyAliased_; - return *this; - } - - PhysicalDeviceFeatures& setVariableMultisampleRate( Bool32 variableMultisampleRate_ ) - { - variableMultisampleRate = variableMultisampleRate_; - return *this; - } - - PhysicalDeviceFeatures& setInheritedQueries( Bool32 inheritedQueries_ ) - { - inheritedQueries = inheritedQueries_; - return *this; - } - - operator const VkPhysicalDeviceFeatures&() const - { - return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this); - } - - bool operator==( PhysicalDeviceFeatures const& rhs ) const - { - return ( robustBufferAccess == rhs.robustBufferAccess ) - && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) - && ( imageCubeArray == rhs.imageCubeArray ) - && ( independentBlend == rhs.independentBlend ) - && ( geometryShader == rhs.geometryShader ) - && ( tessellationShader == rhs.tessellationShader ) - && ( sampleRateShading == rhs.sampleRateShading ) - && ( dualSrcBlend == rhs.dualSrcBlend ) - && ( logicOp == rhs.logicOp ) - && ( multiDrawIndirect == rhs.multiDrawIndirect ) - && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) - && ( depthClamp == rhs.depthClamp ) - && ( depthBiasClamp == rhs.depthBiasClamp ) - && ( fillModeNonSolid == rhs.fillModeNonSolid ) - && ( depthBounds == rhs.depthBounds ) - && ( wideLines == rhs.wideLines ) - && ( largePoints == rhs.largePoints ) - && ( alphaToOne == rhs.alphaToOne ) - && ( multiViewport == rhs.multiViewport ) - && ( samplerAnisotropy == rhs.samplerAnisotropy ) - && ( textureCompressionETC2 == rhs.textureCompressionETC2 ) - && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) - && ( textureCompressionBC == rhs.textureCompressionBC ) - && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) - && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) - && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) - && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) - && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) - && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) - && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) - && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) - && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) - && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) - && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) - && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) - && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) - && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) - && ( shaderClipDistance == rhs.shaderClipDistance ) - && ( shaderCullDistance == rhs.shaderCullDistance ) - && ( shaderFloat64 == rhs.shaderFloat64 ) - && ( shaderInt64 == rhs.shaderInt64 ) - && ( shaderInt16 == rhs.shaderInt16 ) - && ( shaderResourceResidency == rhs.shaderResourceResidency ) - && ( shaderResourceMinLod == rhs.shaderResourceMinLod ) - && ( sparseBinding == rhs.sparseBinding ) - && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) - && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) - && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) - && ( sparseResidency2Samples == rhs.sparseResidency2Samples ) - && ( sparseResidency4Samples == rhs.sparseResidency4Samples ) - && ( sparseResidency8Samples == rhs.sparseResidency8Samples ) - && ( sparseResidency16Samples == rhs.sparseResidency16Samples ) - && ( sparseResidencyAliased == rhs.sparseResidencyAliased ) - && ( variableMultisampleRate == rhs.variableMultisampleRate ) - && ( inheritedQueries == rhs.inheritedQueries ); - } - - bool operator!=( PhysicalDeviceFeatures const& rhs ) const - { - return !operator==( rhs ); - } - - Bool32 robustBufferAccess; - Bool32 fullDrawIndexUint32; - Bool32 imageCubeArray; - Bool32 independentBlend; - Bool32 geometryShader; - Bool32 tessellationShader; - Bool32 sampleRateShading; - Bool32 dualSrcBlend; - Bool32 logicOp; - Bool32 multiDrawIndirect; - Bool32 drawIndirectFirstInstance; - Bool32 depthClamp; - Bool32 depthBiasClamp; - Bool32 fillModeNonSolid; - Bool32 depthBounds; - Bool32 wideLines; - Bool32 largePoints; - Bool32 alphaToOne; - Bool32 multiViewport; - Bool32 samplerAnisotropy; - Bool32 textureCompressionETC2; - Bool32 textureCompressionASTC_LDR; - Bool32 textureCompressionBC; - Bool32 occlusionQueryPrecise; - Bool32 pipelineStatisticsQuery; - Bool32 vertexPipelineStoresAndAtomics; - Bool32 fragmentStoresAndAtomics; - Bool32 shaderTessellationAndGeometryPointSize; - Bool32 shaderImageGatherExtended; - Bool32 shaderStorageImageExtendedFormats; - Bool32 shaderStorageImageMultisample; - Bool32 shaderStorageImageReadWithoutFormat; - Bool32 shaderStorageImageWriteWithoutFormat; - Bool32 shaderUniformBufferArrayDynamicIndexing; - Bool32 shaderSampledImageArrayDynamicIndexing; - Bool32 shaderStorageBufferArrayDynamicIndexing; - Bool32 shaderStorageImageArrayDynamicIndexing; - Bool32 shaderClipDistance; - Bool32 shaderCullDistance; - Bool32 shaderFloat64; - Bool32 shaderInt64; - Bool32 shaderInt16; - Bool32 shaderResourceResidency; - Bool32 shaderResourceMinLod; - Bool32 sparseBinding; - Bool32 sparseResidencyBuffer; - Bool32 sparseResidencyImage2D; - Bool32 sparseResidencyImage3D; - Bool32 sparseResidency2Samples; - Bool32 sparseResidency4Samples; - Bool32 sparseResidency8Samples; - Bool32 sparseResidency16Samples; - Bool32 sparseResidencyAliased; - Bool32 variableMultisampleRate; - Bool32 inheritedQueries; - }; - static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSparseProperties - { - operator const VkPhysicalDeviceSparseProperties&() const - { - return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this); - } - - bool operator==( PhysicalDeviceSparseProperties const& rhs ) const - { - return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) - && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) - && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) - && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) - && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); - } - - bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const - { - return !operator==( rhs ); - } - - Bool32 residencyStandard2DBlockShape; - Bool32 residencyStandard2DMultisampleBlockShape; - Bool32 residencyStandard3DBlockShape; - Bool32 residencyAlignedMipSize; - Bool32 residencyNonResidentStrict; - }; - static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" ); - - struct DrawIndirectCommand - { - DrawIndirectCommand( uint32_t vertexCount_ = 0, uint32_t instanceCount_ = 0, uint32_t firstVertex_ = 0, uint32_t firstInstance_ = 0 ) - : vertexCount( vertexCount_ ) - , instanceCount( instanceCount_ ) - , firstVertex( firstVertex_ ) - , firstInstance( firstInstance_ ) - { - } - - DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); - } - - DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); - return *this; - } - DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ ) - { - vertexCount = vertexCount_; - return *this; - } - - DrawIndirectCommand& setInstanceCount( uint32_t instanceCount_ ) - { - instanceCount = instanceCount_; - return *this; - } - - DrawIndirectCommand& setFirstVertex( uint32_t firstVertex_ ) - { - firstVertex = firstVertex_; - return *this; - } - - DrawIndirectCommand& setFirstInstance( uint32_t firstInstance_ ) - { - firstInstance = firstInstance_; - return *this; - } - - operator const VkDrawIndirectCommand&() const - { - return *reinterpret_cast<const VkDrawIndirectCommand*>(this); - } - - bool operator==( DrawIndirectCommand const& rhs ) const - { - return ( vertexCount == rhs.vertexCount ) - && ( instanceCount == rhs.instanceCount ) - && ( firstVertex == rhs.firstVertex ) - && ( firstInstance == rhs.firstInstance ); - } - - bool operator!=( DrawIndirectCommand const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; - }; - static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" ); - - struct DrawIndexedIndirectCommand - { - DrawIndexedIndirectCommand( uint32_t indexCount_ = 0, uint32_t instanceCount_ = 0, uint32_t firstIndex_ = 0, int32_t vertexOffset_ = 0, uint32_t firstInstance_ = 0 ) - : indexCount( indexCount_ ) - , instanceCount( instanceCount_ ) - , firstIndex( firstIndex_ ) - , vertexOffset( vertexOffset_ ) - , firstInstance( firstInstance_ ) - { - } - - DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); - } - - DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); - return *this; - } - DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ ) - { - indexCount = indexCount_; - return *this; - } - - DrawIndexedIndirectCommand& setInstanceCount( uint32_t instanceCount_ ) - { - instanceCount = instanceCount_; - return *this; - } - - DrawIndexedIndirectCommand& setFirstIndex( uint32_t firstIndex_ ) - { - firstIndex = firstIndex_; - return *this; - } - - DrawIndexedIndirectCommand& setVertexOffset( int32_t vertexOffset_ ) - { - vertexOffset = vertexOffset_; - return *this; - } - - DrawIndexedIndirectCommand& setFirstInstance( uint32_t firstInstance_ ) - { - firstInstance = firstInstance_; - return *this; - } - - operator const VkDrawIndexedIndirectCommand&() const - { - return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this); - } - - bool operator==( DrawIndexedIndirectCommand const& rhs ) const - { - return ( indexCount == rhs.indexCount ) - && ( instanceCount == rhs.instanceCount ) - && ( firstIndex == rhs.firstIndex ) - && ( vertexOffset == rhs.vertexOffset ) - && ( firstInstance == rhs.firstInstance ); - } - - bool operator!=( DrawIndexedIndirectCommand const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; - }; - static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" ); - - struct DispatchIndirectCommand - { - DispatchIndirectCommand( uint32_t x_ = 0, uint32_t y_ = 0, uint32_t z_ = 0 ) - : x( x_ ) - , y( y_ ) - , z( z_ ) - { - } - - DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); - } - - DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) - { - memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); - return *this; - } - DispatchIndirectCommand& setX( uint32_t x_ ) - { - x = x_; - return *this; - } - - DispatchIndirectCommand& setY( uint32_t y_ ) - { - y = y_; - return *this; - } - - DispatchIndirectCommand& setZ( uint32_t z_ ) - { - z = z_; - return *this; - } - - operator const VkDispatchIndirectCommand&() const - { - return *reinterpret_cast<const VkDispatchIndirectCommand*>(this); - } - - bool operator==( DispatchIndirectCommand const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( z == rhs.z ); - } - - bool operator!=( DispatchIndirectCommand const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t x; - uint32_t y; - uint32_t z; - }; - static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" ); - - struct DisplayPlanePropertiesKHR - { - operator const VkDisplayPlanePropertiesKHR&() const - { - return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this); - } - - bool operator==( DisplayPlanePropertiesKHR const& rhs ) const - { - return ( currentDisplay == rhs.currentDisplay ) - && ( currentStackIndex == rhs.currentStackIndex ); - } - - bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayKHR currentDisplay; - uint32_t currentStackIndex; - }; - static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" ); - - struct DisplayModeParametersKHR - { - DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(), uint32_t refreshRate_ = 0 ) - : visibleRegion( visibleRegion_ ) - , refreshRate( refreshRate_ ) - { - } - - DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); - } - - DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); - return *this; - } - DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ ) - { - visibleRegion = visibleRegion_; - return *this; - } - - DisplayModeParametersKHR& setRefreshRate( uint32_t refreshRate_ ) - { - refreshRate = refreshRate_; - return *this; - } - - operator const VkDisplayModeParametersKHR&() const - { - return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this); - } - - bool operator==( DisplayModeParametersKHR const& rhs ) const - { - return ( visibleRegion == rhs.visibleRegion ) - && ( refreshRate == rhs.refreshRate ); - } - - bool operator!=( DisplayModeParametersKHR const& rhs ) const - { - return !operator==( rhs ); - } - - Extent2D visibleRegion; - uint32_t refreshRate; - }; - static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" ); - - struct DisplayModePropertiesKHR - { - operator const VkDisplayModePropertiesKHR&() const - { - return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this); - } - - bool operator==( DisplayModePropertiesKHR const& rhs ) const - { - return ( displayMode == rhs.displayMode ) - && ( parameters == rhs.parameters ); - } - - bool operator!=( DisplayModePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayModeKHR displayMode; - DisplayModeParametersKHR parameters; - }; - static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" ); - - struct RectLayerKHR - { - RectLayerKHR( Offset2D offset_ = Offset2D(), Extent2D extent_ = Extent2D(), uint32_t layer_ = 0 ) - : offset( offset_ ) - , extent( extent_ ) - , layer( layer_ ) - { - } - - RectLayerKHR( VkRectLayerKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( RectLayerKHR ) ); - } - - RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( RectLayerKHR ) ); - return *this; - } - RectLayerKHR& setOffset( Offset2D offset_ ) - { - offset = offset_; - return *this; - } - - RectLayerKHR& setExtent( Extent2D extent_ ) - { - extent = extent_; - return *this; - } - - RectLayerKHR& setLayer( uint32_t layer_ ) - { - layer = layer_; - return *this; - } - - operator const VkRectLayerKHR&() const - { - return *reinterpret_cast<const VkRectLayerKHR*>(this); - } - - bool operator==( RectLayerKHR const& rhs ) const - { - return ( offset == rhs.offset ) - && ( extent == rhs.extent ) - && ( layer == rhs.layer ); - } - - bool operator!=( RectLayerKHR const& rhs ) const - { - return !operator==( rhs ); - } - - Offset2D offset; - Extent2D extent; - uint32_t layer; - }; - static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" ); - - struct PresentRegionKHR - { - PresentRegionKHR( uint32_t rectangleCount_ = 0, const RectLayerKHR* pRectangles_ = nullptr ) - : rectangleCount( rectangleCount_ ) - , pRectangles( pRectangles_ ) - { - } - - PresentRegionKHR( VkPresentRegionKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); - } - - PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); - return *this; - } - PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ ) - { - rectangleCount = rectangleCount_; - return *this; - } - - PresentRegionKHR& setPRectangles( const RectLayerKHR* pRectangles_ ) - { - pRectangles = pRectangles_; - return *this; - } - - operator const VkPresentRegionKHR&() const - { - return *reinterpret_cast<const VkPresentRegionKHR*>(this); - } - - bool operator==( PresentRegionKHR const& rhs ) const - { - return ( rectangleCount == rhs.rectangleCount ) - && ( pRectangles == rhs.pRectangles ); - } - - bool operator!=( PresentRegionKHR const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t rectangleCount; - const RectLayerKHR* pRectangles; - }; - static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); - - struct XYColorEXT - { - XYColorEXT( float x_ = 0, float y_ = 0 ) - : x( x_ ) - , y( y_ ) - { - } - - XYColorEXT( VkXYColorEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( XYColorEXT ) ); - } - - XYColorEXT& operator=( VkXYColorEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( XYColorEXT ) ); - return *this; - } - XYColorEXT& setX( float x_ ) - { - x = x_; - return *this; - } - - XYColorEXT& setY( float y_ ) - { - y = y_; - return *this; - } - - operator const VkXYColorEXT&() const - { - return *reinterpret_cast<const VkXYColorEXT*>(this); - } - - bool operator==( XYColorEXT const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ); - } - - bool operator!=( XYColorEXT const& rhs ) const - { - return !operator==( rhs ); - } - - float x; - float y; - }; - static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); - - struct RefreshCycleDurationGOOGLE - { - RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = 0 ) - : refreshDuration( refreshDuration_ ) - { - } - - RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); - } - - RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); - return *this; - } - RefreshCycleDurationGOOGLE& setRefreshDuration( uint64_t refreshDuration_ ) - { - refreshDuration = refreshDuration_; - return *this; - } - - operator const VkRefreshCycleDurationGOOGLE&() const - { - return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>(this); - } - - bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const - { - return ( refreshDuration == rhs.refreshDuration ); - } - - bool operator!=( RefreshCycleDurationGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - uint64_t refreshDuration; - }; - static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" ); - - struct PastPresentationTimingGOOGLE - { - PastPresentationTimingGOOGLE( uint32_t presentID_ = 0, uint64_t desiredPresentTime_ = 0, uint64_t actualPresentTime_ = 0, uint64_t earliestPresentTime_ = 0, uint64_t presentMargin_ = 0 ) - : presentID( presentID_ ) - , desiredPresentTime( desiredPresentTime_ ) - , actualPresentTime( actualPresentTime_ ) - , earliestPresentTime( earliestPresentTime_ ) - , presentMargin( presentMargin_ ) - { - } - - PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); - } - - PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); - return *this; - } - PastPresentationTimingGOOGLE& setPresentID( uint32_t presentID_ ) - { - presentID = presentID_; - return *this; - } - - PastPresentationTimingGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ ) - { - desiredPresentTime = desiredPresentTime_; - return *this; - } - - PastPresentationTimingGOOGLE& setActualPresentTime( uint64_t actualPresentTime_ ) - { - actualPresentTime = actualPresentTime_; - return *this; - } - - PastPresentationTimingGOOGLE& setEarliestPresentTime( uint64_t earliestPresentTime_ ) - { - earliestPresentTime = earliestPresentTime_; - return *this; - } - - PastPresentationTimingGOOGLE& setPresentMargin( uint64_t presentMargin_ ) - { - presentMargin = presentMargin_; - return *this; - } - - operator const VkPastPresentationTimingGOOGLE&() const - { - return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>(this); - } - - bool operator==( PastPresentationTimingGOOGLE const& rhs ) const - { - return ( presentID == rhs.presentID ) - && ( desiredPresentTime == rhs.desiredPresentTime ) - && ( actualPresentTime == rhs.actualPresentTime ) - && ( earliestPresentTime == rhs.earliestPresentTime ) - && ( presentMargin == rhs.presentMargin ); - } - - bool operator!=( PastPresentationTimingGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t presentID; - uint64_t desiredPresentTime; - uint64_t actualPresentTime; - uint64_t earliestPresentTime; - uint64_t presentMargin; - }; - static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" ); - - struct PresentTimeGOOGLE - { - PresentTimeGOOGLE( uint32_t presentID_ = 0, uint64_t desiredPresentTime_ = 0 ) - : presentID( presentID_ ) - , desiredPresentTime( desiredPresentTime_ ) - { - } - - PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); - } - - PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); - return *this; - } - PresentTimeGOOGLE& setPresentID( uint32_t presentID_ ) - { - presentID = presentID_; - return *this; - } - - PresentTimeGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ ) - { - desiredPresentTime = desiredPresentTime_; - return *this; - } - - operator const VkPresentTimeGOOGLE&() const - { - return *reinterpret_cast<const VkPresentTimeGOOGLE*>(this); - } - - bool operator==( PresentTimeGOOGLE const& rhs ) const - { - return ( presentID == rhs.presentID ) - && ( desiredPresentTime == rhs.desiredPresentTime ); - } - - bool operator!=( PresentTimeGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t presentID; - uint64_t desiredPresentTime; - }; - static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); - - struct ViewportWScalingNV - { - ViewportWScalingNV( float xcoeff_ = 0, float ycoeff_ = 0 ) - : xcoeff( xcoeff_ ) - , ycoeff( ycoeff_ ) - { - } - - ViewportWScalingNV( VkViewportWScalingNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); - } - - ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); - return *this; - } - ViewportWScalingNV& setXcoeff( float xcoeff_ ) - { - xcoeff = xcoeff_; - return *this; - } - - ViewportWScalingNV& setYcoeff( float ycoeff_ ) - { - ycoeff = ycoeff_; - return *this; - } - - operator const VkViewportWScalingNV&() const - { - return *reinterpret_cast<const VkViewportWScalingNV*>(this); - } - - bool operator==( ViewportWScalingNV const& rhs ) const - { - return ( xcoeff == rhs.xcoeff ) - && ( ycoeff == rhs.ycoeff ); - } - - bool operator!=( ViewportWScalingNV const& rhs ) const - { - return !operator==( rhs ); - } - - float xcoeff; - float ycoeff; - }; - static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); - - struct SampleLocationEXT - { - SampleLocationEXT( float x_ = 0, float y_ = 0 ) - : x( x_ ) - , y( y_ ) - { - } - - SampleLocationEXT( VkSampleLocationEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationEXT ) ); - } - - SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationEXT ) ); - return *this; - } - SampleLocationEXT& setX( float x_ ) - { - x = x_; - return *this; - } - - SampleLocationEXT& setY( float y_ ) - { - y = y_; - return *this; - } - - operator const VkSampleLocationEXT&() const - { - return *reinterpret_cast<const VkSampleLocationEXT*>(this); - } - - bool operator==( SampleLocationEXT const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ); - } - - bool operator!=( SampleLocationEXT const& rhs ) const - { - return !operator==( rhs ); - } - - float x; - float y; - }; - static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); - - struct ShaderResourceUsageAMD - { - operator const VkShaderResourceUsageAMD&() const - { - return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this); - } - - bool operator==( ShaderResourceUsageAMD const& rhs ) const - { - return ( numUsedVgprs == rhs.numUsedVgprs ) - && ( numUsedSgprs == rhs.numUsedSgprs ) - && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) - && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) - && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); - } - - bool operator!=( ShaderResourceUsageAMD const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t numUsedVgprs; - uint32_t numUsedSgprs; - uint32_t ldsSizePerLocalWorkGroup; - size_t ldsUsageSizeInBytes; - size_t scratchMemUsageInBytes; - }; - static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" ); - - enum class ImageLayout - { - eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, - eGeneral = VK_IMAGE_LAYOUT_GENERAL, - eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, - eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED, - ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, - eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, - eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR, - eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR - }; - - struct DescriptorImageInfo - { - DescriptorImageInfo( Sampler sampler_ = Sampler(), ImageView imageView_ = ImageView(), ImageLayout imageLayout_ = ImageLayout::eUndefined ) - : sampler( sampler_ ) - , imageView( imageView_ ) - , imageLayout( imageLayout_ ) - { - } - - DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); - } - - DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); - return *this; - } - DescriptorImageInfo& setSampler( Sampler sampler_ ) - { - sampler = sampler_; - return *this; - } - - DescriptorImageInfo& setImageView( ImageView imageView_ ) - { - imageView = imageView_; - return *this; - } - - DescriptorImageInfo& setImageLayout( ImageLayout imageLayout_ ) - { - imageLayout = imageLayout_; - return *this; - } - - operator const VkDescriptorImageInfo&() const - { - return *reinterpret_cast<const VkDescriptorImageInfo*>(this); - } - - bool operator==( DescriptorImageInfo const& rhs ) const - { - return ( sampler == rhs.sampler ) - && ( imageView == rhs.imageView ) - && ( imageLayout == rhs.imageLayout ); - } - - bool operator!=( DescriptorImageInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Sampler sampler; - ImageView imageView; - ImageLayout imageLayout; - }; - static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" ); - - struct AttachmentReference - { - AttachmentReference( uint32_t attachment_ = 0, ImageLayout layout_ = ImageLayout::eUndefined ) - : attachment( attachment_ ) - , layout( layout_ ) - { - } - - AttachmentReference( VkAttachmentReference const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentReference ) ); - } - - AttachmentReference& operator=( VkAttachmentReference const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentReference ) ); - return *this; - } - AttachmentReference& setAttachment( uint32_t attachment_ ) - { - attachment = attachment_; - return *this; - } - - AttachmentReference& setLayout( ImageLayout layout_ ) - { - layout = layout_; - return *this; - } - - operator const VkAttachmentReference&() const - { - return *reinterpret_cast<const VkAttachmentReference*>(this); - } - - bool operator==( AttachmentReference const& rhs ) const - { - return ( attachment == rhs.attachment ) - && ( layout == rhs.layout ); - } - - bool operator!=( AttachmentReference const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t attachment; - ImageLayout layout; - }; - static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); - - enum class AttachmentLoadOp - { - eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, - eClear = VK_ATTACHMENT_LOAD_OP_CLEAR, - eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE - }; - - enum class AttachmentStoreOp - { - eStore = VK_ATTACHMENT_STORE_OP_STORE, - eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE - }; - - enum class ImageType - { - e1D = VK_IMAGE_TYPE_1D, - e2D = VK_IMAGE_TYPE_2D, - e3D = VK_IMAGE_TYPE_3D - }; - - enum class ImageTiling - { - eOptimal = VK_IMAGE_TILING_OPTIMAL, - eLinear = VK_IMAGE_TILING_LINEAR - }; - - enum class ImageViewType - { - e1D = VK_IMAGE_VIEW_TYPE_1D, - e2D = VK_IMAGE_VIEW_TYPE_2D, - e3D = VK_IMAGE_VIEW_TYPE_3D, - eCube = VK_IMAGE_VIEW_TYPE_CUBE, - e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY, - e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY, - eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - }; - - enum class CommandBufferLevel - { - ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, - eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY - }; - - enum class ComponentSwizzle - { - eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY, - eZero = VK_COMPONENT_SWIZZLE_ZERO, - eOne = VK_COMPONENT_SWIZZLE_ONE, - eR = VK_COMPONENT_SWIZZLE_R, - eG = VK_COMPONENT_SWIZZLE_G, - eB = VK_COMPONENT_SWIZZLE_B, - eA = VK_COMPONENT_SWIZZLE_A - }; - - struct ComponentMapping - { - ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity, ComponentSwizzle g_ = ComponentSwizzle::eIdentity, ComponentSwizzle b_ = ComponentSwizzle::eIdentity, ComponentSwizzle a_ = ComponentSwizzle::eIdentity ) - : r( r_ ) - , g( g_ ) - , b( b_ ) - , a( a_ ) - { - } - - ComponentMapping( VkComponentMapping const & rhs ) - { - memcpy( this, &rhs, sizeof( ComponentMapping ) ); - } - - ComponentMapping& operator=( VkComponentMapping const & rhs ) - { - memcpy( this, &rhs, sizeof( ComponentMapping ) ); - return *this; - } - ComponentMapping& setR( ComponentSwizzle r_ ) - { - r = r_; - return *this; - } - - ComponentMapping& setG( ComponentSwizzle g_ ) - { - g = g_; - return *this; - } - - ComponentMapping& setB( ComponentSwizzle b_ ) - { - b = b_; - return *this; - } - - ComponentMapping& setA( ComponentSwizzle a_ ) - { - a = a_; - return *this; - } - - operator const VkComponentMapping&() const - { - return *reinterpret_cast<const VkComponentMapping*>(this); - } - - bool operator==( ComponentMapping const& rhs ) const - { - return ( r == rhs.r ) - && ( g == rhs.g ) - && ( b == rhs.b ) - && ( a == rhs.a ); - } - - bool operator!=( ComponentMapping const& rhs ) const - { - return !operator==( rhs ); - } - - ComponentSwizzle r; - ComponentSwizzle g; - ComponentSwizzle b; - ComponentSwizzle a; - }; - static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" ); - - enum class DescriptorType - { - eSampler = VK_DESCRIPTOR_TYPE_SAMPLER, - eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, - eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, - eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, - eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, - eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, - eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, - eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - }; - - struct DescriptorPoolSize - { - DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0 ) - : type( type_ ) - , descriptorCount( descriptorCount_ ) - { - } - - DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); - } - - DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); - return *this; - } - DescriptorPoolSize& setType( DescriptorType type_ ) - { - type = type_; - return *this; - } - - DescriptorPoolSize& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - operator const VkDescriptorPoolSize&() const - { - return *reinterpret_cast<const VkDescriptorPoolSize*>(this); - } - - bool operator==( DescriptorPoolSize const& rhs ) const - { - return ( type == rhs.type ) - && ( descriptorCount == rhs.descriptorCount ); - } - - bool operator!=( DescriptorPoolSize const& rhs ) const - { - return !operator==( rhs ); - } - - DescriptorType type; - uint32_t descriptorCount; - }; - static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); - - struct DescriptorUpdateTemplateEntryKHR - { - DescriptorUpdateTemplateEntryKHR( uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, size_t offset_ = 0, size_t stride_ = 0 ) - : dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - , descriptorType( descriptorType_ ) - , offset( offset_ ) - , stride( stride_ ) - { - } - - DescriptorUpdateTemplateEntryKHR( VkDescriptorUpdateTemplateEntryKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) ); - } - - DescriptorUpdateTemplateEntryKHR& operator=( VkDescriptorUpdateTemplateEntryKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) ); - return *this; - } - DescriptorUpdateTemplateEntryKHR& setDstBinding( uint32_t dstBinding_ ) - { - dstBinding = dstBinding_; - return *this; - } - - DescriptorUpdateTemplateEntryKHR& setDstArrayElement( uint32_t dstArrayElement_ ) - { - dstArrayElement = dstArrayElement_; - return *this; - } - - DescriptorUpdateTemplateEntryKHR& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - DescriptorUpdateTemplateEntryKHR& setDescriptorType( DescriptorType descriptorType_ ) - { - descriptorType = descriptorType_; - return *this; - } - - DescriptorUpdateTemplateEntryKHR& setOffset( size_t offset_ ) - { - offset = offset_; - return *this; - } - - DescriptorUpdateTemplateEntryKHR& setStride( size_t stride_ ) - { - stride = stride_; - return *this; - } - - operator const VkDescriptorUpdateTemplateEntryKHR&() const - { - return *reinterpret_cast<const VkDescriptorUpdateTemplateEntryKHR*>(this); - } - - bool operator==( DescriptorUpdateTemplateEntryKHR const& rhs ) const - { - return ( dstBinding == rhs.dstBinding ) - && ( dstArrayElement == rhs.dstArrayElement ) - && ( descriptorCount == rhs.descriptorCount ) - && ( descriptorType == rhs.descriptorType ) - && ( offset == rhs.offset ) - && ( stride == rhs.stride ); - } - - bool operator!=( DescriptorUpdateTemplateEntryKHR const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - DescriptorType descriptorType; - size_t offset; - size_t stride; - }; - static_assert( sizeof( DescriptorUpdateTemplateEntryKHR ) == sizeof( VkDescriptorUpdateTemplateEntryKHR ), "struct and wrapper have different size!" ); - - enum class QueryType - { - eOcclusion = VK_QUERY_TYPE_OCCLUSION, - ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, - eTimestamp = VK_QUERY_TYPE_TIMESTAMP - }; - - enum class BorderColor - { - eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, - eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, - eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, - eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK, - eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, - eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE - }; - - enum class PipelineBindPoint - { - eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, - eCompute = VK_PIPELINE_BIND_POINT_COMPUTE - }; - - enum class PipelineCacheHeaderVersion - { - eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE - }; - - enum class PrimitiveTopology - { - ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, - eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, - eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, - eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, - eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, - eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, - eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, - eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, - ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - }; - - enum class SharingMode - { - eExclusive = VK_SHARING_MODE_EXCLUSIVE, - eConcurrent = VK_SHARING_MODE_CONCURRENT - }; - - enum class IndexType - { - eUint16 = VK_INDEX_TYPE_UINT16, - eUint32 = VK_INDEX_TYPE_UINT32 - }; - - enum class Filter - { - eNearest = VK_FILTER_NEAREST, - eLinear = VK_FILTER_LINEAR, - eCubicIMG = VK_FILTER_CUBIC_IMG - }; - - enum class SamplerMipmapMode - { - eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, - eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR - }; - - enum class SamplerAddressMode - { - eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT, - eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, - eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, - eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, - eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - }; - - enum class CompareOp - { - eNever = VK_COMPARE_OP_NEVER, - eLess = VK_COMPARE_OP_LESS, - eEqual = VK_COMPARE_OP_EQUAL, - eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL, - eGreater = VK_COMPARE_OP_GREATER, - eNotEqual = VK_COMPARE_OP_NOT_EQUAL, - eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL, - eAlways = VK_COMPARE_OP_ALWAYS - }; - - enum class PolygonMode - { - eFill = VK_POLYGON_MODE_FILL, - eLine = VK_POLYGON_MODE_LINE, - ePoint = VK_POLYGON_MODE_POINT, - eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV - }; - - enum class CullModeFlagBits - { - eNone = VK_CULL_MODE_NONE, - eFront = VK_CULL_MODE_FRONT_BIT, - eBack = VK_CULL_MODE_BACK_BIT, - eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK - }; - - using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>; - - VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 ) - { - return CullModeFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits ) - { - return ~( CullModeFlags( bits ) ); - } - - template <> struct FlagTraits<CullModeFlagBits> - { - enum - { - allFlags = VkFlags(CullModeFlagBits::eNone) | VkFlags(CullModeFlagBits::eFront) | VkFlags(CullModeFlagBits::eBack) | VkFlags(CullModeFlagBits::eFrontAndBack) - }; - }; - - enum class FrontFace - { - eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE, - eClockwise = VK_FRONT_FACE_CLOCKWISE - }; - - enum class BlendFactor - { - eZero = VK_BLEND_FACTOR_ZERO, - eOne = VK_BLEND_FACTOR_ONE, - eSrcColor = VK_BLEND_FACTOR_SRC_COLOR, - eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, - eDstColor = VK_BLEND_FACTOR_DST_COLOR, - eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, - eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA, - eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA, - eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, - eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR, - eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, - eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA, - eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, - eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, - eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR, - eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, - eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA, - eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - }; - - enum class BlendOp - { - eAdd = VK_BLEND_OP_ADD, - eSubtract = VK_BLEND_OP_SUBTRACT, - eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT, - eMin = VK_BLEND_OP_MIN, - eMax = VK_BLEND_OP_MAX, - eZeroEXT = VK_BLEND_OP_ZERO_EXT, - eSrcEXT = VK_BLEND_OP_SRC_EXT, - eDstEXT = VK_BLEND_OP_DST_EXT, - eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT, - eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT, - eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT, - eDstInEXT = VK_BLEND_OP_DST_IN_EXT, - eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT, - eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT, - eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT, - eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT, - eXorEXT = VK_BLEND_OP_XOR_EXT, - eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT, - eScreenEXT = VK_BLEND_OP_SCREEN_EXT, - eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT, - eDarkenEXT = VK_BLEND_OP_DARKEN_EXT, - eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT, - eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT, - eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT, - eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT, - eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT, - eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT, - eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT, - eInvertEXT = VK_BLEND_OP_INVERT_EXT, - eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT, - eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT, - eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT, - eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT, - eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT, - ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT, - eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT, - eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT, - eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT, - eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT, - eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT, - ePlusEXT = VK_BLEND_OP_PLUS_EXT, - ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT, - ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, - ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT, - eMinusEXT = VK_BLEND_OP_MINUS_EXT, - eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT, - eContrastEXT = VK_BLEND_OP_CONTRAST_EXT, - eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT, - eRedEXT = VK_BLEND_OP_RED_EXT, - eGreenEXT = VK_BLEND_OP_GREEN_EXT, - eBlueEXT = VK_BLEND_OP_BLUE_EXT - }; - - enum class StencilOp - { - eKeep = VK_STENCIL_OP_KEEP, - eZero = VK_STENCIL_OP_ZERO, - eReplace = VK_STENCIL_OP_REPLACE, - eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP, - eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP, - eInvert = VK_STENCIL_OP_INVERT, - eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP, - eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP - }; - - struct StencilOpState - { - 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 ) - : failOp( failOp_ ) - , passOp( passOp_ ) - , depthFailOp( depthFailOp_ ) - , compareOp( compareOp_ ) - , compareMask( compareMask_ ) - , writeMask( writeMask_ ) - , reference( reference_ ) - { - } - - StencilOpState( VkStencilOpState const & rhs ) - { - memcpy( this, &rhs, sizeof( StencilOpState ) ); - } - - StencilOpState& operator=( VkStencilOpState const & rhs ) - { - memcpy( this, &rhs, sizeof( StencilOpState ) ); - return *this; - } - StencilOpState& setFailOp( StencilOp failOp_ ) - { - failOp = failOp_; - return *this; - } - - StencilOpState& setPassOp( StencilOp passOp_ ) - { - passOp = passOp_; - return *this; - } - - StencilOpState& setDepthFailOp( StencilOp depthFailOp_ ) - { - depthFailOp = depthFailOp_; - return *this; - } - - StencilOpState& setCompareOp( CompareOp compareOp_ ) - { - compareOp = compareOp_; - return *this; - } - - StencilOpState& setCompareMask( uint32_t compareMask_ ) - { - compareMask = compareMask_; - return *this; - } - - StencilOpState& setWriteMask( uint32_t writeMask_ ) - { - writeMask = writeMask_; - return *this; - } - - StencilOpState& setReference( uint32_t reference_ ) - { - reference = reference_; - return *this; - } - - operator const VkStencilOpState&() const - { - return *reinterpret_cast<const VkStencilOpState*>(this); - } - - bool operator==( StencilOpState const& rhs ) const - { - return ( failOp == rhs.failOp ) - && ( passOp == rhs.passOp ) - && ( depthFailOp == rhs.depthFailOp ) - && ( compareOp == rhs.compareOp ) - && ( compareMask == rhs.compareMask ) - && ( writeMask == rhs.writeMask ) - && ( reference == rhs.reference ); - } - - bool operator!=( StencilOpState const& rhs ) const - { - return !operator==( rhs ); - } - - StencilOp failOp; - StencilOp passOp; - StencilOp depthFailOp; - CompareOp compareOp; - uint32_t compareMask; - uint32_t writeMask; - uint32_t reference; - }; - static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); - - enum class LogicOp - { - eClear = VK_LOGIC_OP_CLEAR, - eAnd = VK_LOGIC_OP_AND, - eAndReverse = VK_LOGIC_OP_AND_REVERSE, - eCopy = VK_LOGIC_OP_COPY, - eAndInverted = VK_LOGIC_OP_AND_INVERTED, - eNoOp = VK_LOGIC_OP_NO_OP, - eXor = VK_LOGIC_OP_XOR, - eOr = VK_LOGIC_OP_OR, - eNor = VK_LOGIC_OP_NOR, - eEquivalent = VK_LOGIC_OP_EQUIVALENT, - eInvert = VK_LOGIC_OP_INVERT, - eOrReverse = VK_LOGIC_OP_OR_REVERSE, - eCopyInverted = VK_LOGIC_OP_COPY_INVERTED, - eOrInverted = VK_LOGIC_OP_OR_INVERTED, - eNand = VK_LOGIC_OP_NAND, - eSet = VK_LOGIC_OP_SET - }; - - enum class InternalAllocationType - { - eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - }; - - enum class SystemAllocationScope - { - eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, - eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, - eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE, - eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, - eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - }; - - enum class PhysicalDeviceType - { - eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER, - eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, - eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, - eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, - eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU - }; - - enum class VertexInputRate - { - eVertex = VK_VERTEX_INPUT_RATE_VERTEX, - eInstance = VK_VERTEX_INPUT_RATE_INSTANCE - }; - - struct VertexInputBindingDescription - { - VertexInputBindingDescription( uint32_t binding_ = 0, uint32_t stride_ = 0, VertexInputRate inputRate_ = VertexInputRate::eVertex ) - : binding( binding_ ) - , stride( stride_ ) - , inputRate( inputRate_ ) - { - } - - VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); - } - - VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); - return *this; - } - VertexInputBindingDescription& setBinding( uint32_t binding_ ) - { - binding = binding_; - return *this; - } - - VertexInputBindingDescription& setStride( uint32_t stride_ ) - { - stride = stride_; - return *this; - } - - VertexInputBindingDescription& setInputRate( VertexInputRate inputRate_ ) - { - inputRate = inputRate_; - return *this; - } - - operator const VkVertexInputBindingDescription&() const - { - return *reinterpret_cast<const VkVertexInputBindingDescription*>(this); - } - - bool operator==( VertexInputBindingDescription const& rhs ) const - { - return ( binding == rhs.binding ) - && ( stride == rhs.stride ) - && ( inputRate == rhs.inputRate ); - } - - bool operator!=( VertexInputBindingDescription const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t binding; - uint32_t stride; - VertexInputRate inputRate; - }; - static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" ); - - enum class Format - { - eUndefined = VK_FORMAT_UNDEFINED, - eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8, - eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, - eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, - eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16, - eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16, - eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, - eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, - eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, - eR8Unorm = VK_FORMAT_R8_UNORM, - eR8Snorm = VK_FORMAT_R8_SNORM, - eR8Uscaled = VK_FORMAT_R8_USCALED, - eR8Sscaled = VK_FORMAT_R8_SSCALED, - eR8Uint = VK_FORMAT_R8_UINT, - eR8Sint = VK_FORMAT_R8_SINT, - eR8Srgb = VK_FORMAT_R8_SRGB, - eR8G8Unorm = VK_FORMAT_R8G8_UNORM, - eR8G8Snorm = VK_FORMAT_R8G8_SNORM, - eR8G8Uscaled = VK_FORMAT_R8G8_USCALED, - eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED, - eR8G8Uint = VK_FORMAT_R8G8_UINT, - eR8G8Sint = VK_FORMAT_R8G8_SINT, - eR8G8Srgb = VK_FORMAT_R8G8_SRGB, - eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM, - eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM, - eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED, - eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED, - eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT, - eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT, - eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB, - eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM, - eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM, - eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED, - eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED, - eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT, - eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT, - eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB, - eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM, - eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM, - eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED, - eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED, - eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT, - eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT, - eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB, - eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM, - eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM, - eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED, - eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED, - eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT, - eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT, - eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB, - eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, - eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, - eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, - eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, - eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, - eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, - eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, - eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, - eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, - eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32, - eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32, - eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, - eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, - eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, - eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, - eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32, - eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32, - eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, - eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, - eR16Unorm = VK_FORMAT_R16_UNORM, - eR16Snorm = VK_FORMAT_R16_SNORM, - eR16Uscaled = VK_FORMAT_R16_USCALED, - eR16Sscaled = VK_FORMAT_R16_SSCALED, - eR16Uint = VK_FORMAT_R16_UINT, - eR16Sint = VK_FORMAT_R16_SINT, - eR16Sfloat = VK_FORMAT_R16_SFLOAT, - eR16G16Unorm = VK_FORMAT_R16G16_UNORM, - eR16G16Snorm = VK_FORMAT_R16G16_SNORM, - eR16G16Uscaled = VK_FORMAT_R16G16_USCALED, - eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED, - eR16G16Uint = VK_FORMAT_R16G16_UINT, - eR16G16Sint = VK_FORMAT_R16G16_SINT, - eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT, - eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM, - eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM, - eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED, - eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED, - eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT, - eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT, - eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT, - eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM, - eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM, - eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED, - eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED, - eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT, - eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT, - eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT, - eR32Uint = VK_FORMAT_R32_UINT, - eR32Sint = VK_FORMAT_R32_SINT, - eR32Sfloat = VK_FORMAT_R32_SFLOAT, - eR32G32Uint = VK_FORMAT_R32G32_UINT, - eR32G32Sint = VK_FORMAT_R32G32_SINT, - eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT, - eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT, - eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT, - eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT, - eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT, - eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT, - eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT, - eR64Uint = VK_FORMAT_R64_UINT, - eR64Sint = VK_FORMAT_R64_SINT, - eR64Sfloat = VK_FORMAT_R64_SFLOAT, - eR64G64Uint = VK_FORMAT_R64G64_UINT, - eR64G64Sint = VK_FORMAT_R64G64_SINT, - eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT, - eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT, - eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT, - eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT, - eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT, - eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT, - eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT, - eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, - eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, - eD16Unorm = VK_FORMAT_D16_UNORM, - eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32, - eD32Sfloat = VK_FORMAT_D32_SFLOAT, - eS8Uint = VK_FORMAT_S8_UINT, - eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT, - eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT, - eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT, - eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK, - eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK, - eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, - eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, - eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK, - eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK, - eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK, - eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK, - eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK, - eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK, - eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK, - eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK, - eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK, - eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK, - eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK, - eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK, - eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, - eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, - eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, - eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, - eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, - eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, - eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK, - eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK, - eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, - eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, - eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, - eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, - eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, - eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, - eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, - eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, - eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, - eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, - eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, - eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, - eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, - eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, - eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, - eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, - eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, - eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, - eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, - eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, - eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, - eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, - eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, - eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, - eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, - eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, - eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, - eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, - eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, - eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, - ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, - ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, - ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, - ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, - ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, - ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, - ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, - ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, - eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR, - eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR, - eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, - eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, - eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, - eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, - eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, - eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR, - eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, - eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, - eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, - eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, - eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, - eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, - eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, - eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, - eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, - eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR, - eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, - eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, - eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, - eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, - eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, - eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, - eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, - eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, - eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, - eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR, - eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR, - eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, - eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, - eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, - eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, - eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR - }; - - struct VertexInputAttributeDescription - { - VertexInputAttributeDescription( uint32_t location_ = 0, uint32_t binding_ = 0, Format format_ = Format::eUndefined, uint32_t offset_ = 0 ) - : location( location_ ) - , binding( binding_ ) - , format( format_ ) - , offset( offset_ ) - { - } - - VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); - } - - VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); - return *this; - } - VertexInputAttributeDescription& setLocation( uint32_t location_ ) - { - location = location_; - return *this; - } - - VertexInputAttributeDescription& setBinding( uint32_t binding_ ) - { - binding = binding_; - return *this; - } - - VertexInputAttributeDescription& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - VertexInputAttributeDescription& setOffset( uint32_t offset_ ) - { - offset = offset_; - return *this; - } - - operator const VkVertexInputAttributeDescription&() const - { - return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this); - } - - bool operator==( VertexInputAttributeDescription const& rhs ) const - { - return ( location == rhs.location ) - && ( binding == rhs.binding ) - && ( format == rhs.format ) - && ( offset == rhs.offset ); - } - - bool operator!=( VertexInputAttributeDescription const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t location; - uint32_t binding; - Format format; - uint32_t offset; - }; - static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" ); - - enum class StructureType - { - eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO, - eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, - eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO, - eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, - eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, - eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, - eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, - eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, - eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, - eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, - eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, - eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, - eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, - eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, - eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, - ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, - ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, - ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, - ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, - eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, - eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, - ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, - eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, - eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, - eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, - eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, - eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, - eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, - eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, - eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, - eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, - eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, - eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, - eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, - eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER, - eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, - eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, - eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, - ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, - eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, - eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, - eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, - eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, - eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, - eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, - eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR, - eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, - eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, - eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, - eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, - eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, - eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, - eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, - eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, - eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, - eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, - eRenderPassMultiviewCreateInfoKHX = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX, - ePhysicalDeviceMultiviewFeaturesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX, - ePhysicalDeviceMultiviewPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX, - eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, - eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, - eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, - eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, - eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, - ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, - ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, - eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, - eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, - ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, - eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR, - ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR, - eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR, - ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR, - eMemoryAllocateFlagsInfoKHX = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX, - eDeviceGroupRenderPassBeginInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX, - eDeviceGroupCommandBufferBeginInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX, - eDeviceGroupSubmitInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX, - eDeviceGroupBindSparseInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX, - eAcquireNextImageInfoKHX = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX, - eBindBufferMemoryDeviceGroupInfoKHX = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX, - eBindImageMemoryDeviceGroupInfoKHX = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX, - eDeviceGroupPresentCapabilitiesKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX, - eImageSwapchainCreateInfoKHX = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX, - eBindImageMemorySwapchainInfoKHX = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX, - eDeviceGroupPresentInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX, - eDeviceGroupSwapchainCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX, - eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, - eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, - ePhysicalDeviceGroupPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX, - eDeviceGroupDeviceCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX, - ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, - eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, - ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, - eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, - ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, - eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, - eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, - eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, - eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, - eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, - eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, - eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, - eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, - eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, - ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, - eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, - eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, - eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, - eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, - eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, - eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, - ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, - ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, - ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, - eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, - eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, - eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX, - eCmdProcessCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX, - eCmdReserveSpaceForCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX, - eDeviceGeneratedCommandsLimitsNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX, - eDeviceGeneratedCommandsFeaturesNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX, - ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, - eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, - eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, - eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, - eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, - eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, - ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, - ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, - ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, - ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, - ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, - ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, - ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, - eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, - eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, - ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, - eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, - eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, - eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, - eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, - eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, - eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, - eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, - ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR, - eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR, - eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, - ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR, - ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, - eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, - eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, - ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, - eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, - eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, - eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, - eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, - ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, - eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, - eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, - eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, - ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, - ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, - eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, - eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, - eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, - eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, - eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, - eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, - eImageFormatListCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR, - ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, - ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, - ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, - ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, - ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, - eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR, - eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR, - eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, - eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR, - ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR, - eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR, - eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, - eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, - eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, - eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, - eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, - eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, - eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, - ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT - }; - - struct ApplicationInfo - { - ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 ) - : pApplicationName( pApplicationName_ ) - , applicationVersion( applicationVersion_ ) - , pEngineName( pEngineName_ ) - , engineVersion( engineVersion_ ) - , apiVersion( apiVersion_ ) - { - } - - ApplicationInfo( VkApplicationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ApplicationInfo ) ); - } - - ApplicationInfo& operator=( VkApplicationInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ApplicationInfo ) ); - return *this; - } - ApplicationInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ApplicationInfo& setPApplicationName( const char* pApplicationName_ ) - { - pApplicationName = pApplicationName_; - return *this; - } - - ApplicationInfo& setApplicationVersion( uint32_t applicationVersion_ ) - { - applicationVersion = applicationVersion_; - return *this; - } - - ApplicationInfo& setPEngineName( const char* pEngineName_ ) - { - pEngineName = pEngineName_; - return *this; - } - - ApplicationInfo& setEngineVersion( uint32_t engineVersion_ ) - { - engineVersion = engineVersion_; - return *this; - } - - ApplicationInfo& setApiVersion( uint32_t apiVersion_ ) - { - apiVersion = apiVersion_; - return *this; - } - - operator const VkApplicationInfo&() const - { - return *reinterpret_cast<const VkApplicationInfo*>(this); - } - - bool operator==( ApplicationInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pApplicationName == rhs.pApplicationName ) - && ( applicationVersion == rhs.applicationVersion ) - && ( pEngineName == rhs.pEngineName ) - && ( engineVersion == rhs.engineVersion ) - && ( apiVersion == rhs.apiVersion ); - } - - bool operator!=( ApplicationInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eApplicationInfo; - - public: - const void* pNext = nullptr; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; - }; - static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); - - struct DeviceQueueCreateInfo - { - DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr ) - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueCount( queueCount_ ) - , pQueuePriorities( pQueuePriorities_ ) - { - } - - DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); - } - - DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); - return *this; - } - DeviceQueueCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ ) - { - queueCount = queueCount_; - return *this; - } - - DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ ) - { - pQueuePriorities = pQueuePriorities_; - return *this; - } - - operator const VkDeviceQueueCreateInfo&() const - { - return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this); - } - - bool operator==( DeviceQueueCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueFamilyIndex == rhs.queueFamilyIndex ) - && ( queueCount == rhs.queueCount ) - && ( pQueuePriorities == rhs.pQueuePriorities ); - } - - bool operator!=( DeviceQueueCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceQueueCreateInfo; - - public: - const void* pNext = nullptr; - DeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; - }; - static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" ); - - struct DeviceCreateInfo - { - 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 ) - : flags( flags_ ) - , queueCreateInfoCount( queueCreateInfoCount_ ) - , pQueueCreateInfos( pQueueCreateInfos_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - , pEnabledFeatures( pEnabledFeatures_ ) - { - } - - DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); - } - - DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); - return *this; - } - DeviceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ ) - { - queueCreateInfoCount = queueCreateInfoCount_; - return *this; - } - - DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ ) - { - pQueueCreateInfos = pQueueCreateInfos_; - return *this; - } - - DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ ) - { - enabledLayerCount = enabledLayerCount_; - return *this; - } - - DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ ) - { - ppEnabledLayerNames = ppEnabledLayerNames_; - return *this; - } - - DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) - { - enabledExtensionCount = enabledExtensionCount_; - return *this; - } - - DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ ) - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return *this; - } - - DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ ) - { - pEnabledFeatures = pEnabledFeatures_; - return *this; - } - - operator const VkDeviceCreateInfo&() const - { - return *reinterpret_cast<const VkDeviceCreateInfo*>(this); - } - - bool operator==( DeviceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) - && ( pQueueCreateInfos == rhs.pQueueCreateInfos ) - && ( enabledLayerCount == rhs.enabledLayerCount ) - && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) - && ( enabledExtensionCount == rhs.enabledExtensionCount ) - && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ) - && ( pEnabledFeatures == rhs.pEnabledFeatures ); - } - - bool operator!=( DeviceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceCreateInfo; - - public: - const void* pNext = nullptr; - DeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const DeviceQueueCreateInfo* pQueueCreateInfos; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const PhysicalDeviceFeatures* pEnabledFeatures; - }; - static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); - - struct InstanceCreateInfo - { - 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 ) - : flags( flags_ ) - , pApplicationInfo( pApplicationInfo_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - { - } - - InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); - } - - InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); - return *this; - } - InstanceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - InstanceCreateInfo& setFlags( InstanceCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - InstanceCreateInfo& setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ ) - { - pApplicationInfo = pApplicationInfo_; - return *this; - } - - InstanceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ ) - { - enabledLayerCount = enabledLayerCount_; - return *this; - } - - InstanceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ ) - { - ppEnabledLayerNames = ppEnabledLayerNames_; - return *this; - } - - InstanceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) - { - enabledExtensionCount = enabledExtensionCount_; - return *this; - } - - InstanceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ ) - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return *this; - } - - operator const VkInstanceCreateInfo&() const - { - return *reinterpret_cast<const VkInstanceCreateInfo*>(this); - } - - bool operator==( InstanceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pApplicationInfo == rhs.pApplicationInfo ) - && ( enabledLayerCount == rhs.enabledLayerCount ) - && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) - && ( enabledExtensionCount == rhs.enabledExtensionCount ) - && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ); - } - - bool operator!=( InstanceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eInstanceCreateInfo; - - public: - const void* pNext = nullptr; - InstanceCreateFlags flags; - const ApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - }; - static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" ); - - struct MemoryAllocateInfo - { - MemoryAllocateInfo( DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 ) - : allocationSize( allocationSize_ ) - , memoryTypeIndex( memoryTypeIndex_ ) - { - } - - MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); - } - - MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); - return *this; - } - MemoryAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryAllocateInfo& setAllocationSize( DeviceSize allocationSize_ ) - { - allocationSize = allocationSize_; - return *this; - } - - MemoryAllocateInfo& setMemoryTypeIndex( uint32_t memoryTypeIndex_ ) - { - memoryTypeIndex = memoryTypeIndex_; - return *this; - } - - operator const VkMemoryAllocateInfo&() const - { - return *reinterpret_cast<const VkMemoryAllocateInfo*>(this); - } - - bool operator==( MemoryAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( allocationSize == rhs.allocationSize ) - && ( memoryTypeIndex == rhs.memoryTypeIndex ); - } - - bool operator!=( MemoryAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryAllocateInfo; - - public: - const void* pNext = nullptr; - DeviceSize allocationSize; - uint32_t memoryTypeIndex; - }; - static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); - - struct MappedMemoryRange - { - MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), DeviceSize offset_ = 0, DeviceSize size_ = 0 ) - : memory( memory_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - MappedMemoryRange( VkMappedMemoryRange const & rhs ) - { - memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); - } - - MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) - { - memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); - return *this; - } - MappedMemoryRange& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MappedMemoryRange& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - MappedMemoryRange& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - MappedMemoryRange& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - operator const VkMappedMemoryRange&() const - { - return *reinterpret_cast<const VkMappedMemoryRange*>(this); - } - - bool operator==( MappedMemoryRange const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memory == rhs.memory ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( MappedMemoryRange const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMappedMemoryRange; - - public: - const void* pNext = nullptr; - DeviceMemory memory; - DeviceSize offset; - DeviceSize size; - }; - static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); - - struct WriteDescriptorSet - { - 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 ) - : dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - , descriptorType( descriptorType_ ) - , pImageInfo( pImageInfo_ ) - , pBufferInfo( pBufferInfo_ ) - , pTexelBufferView( pTexelBufferView_ ) - { - } - - WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); - } - - WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); - return *this; - } - WriteDescriptorSet& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - WriteDescriptorSet& setDstSet( DescriptorSet dstSet_ ) - { - dstSet = dstSet_; - return *this; - } - - WriteDescriptorSet& setDstBinding( uint32_t dstBinding_ ) - { - dstBinding = dstBinding_; - return *this; - } - - WriteDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ ) - { - dstArrayElement = dstArrayElement_; - return *this; - } - - WriteDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - WriteDescriptorSet& setDescriptorType( DescriptorType descriptorType_ ) - { - descriptorType = descriptorType_; - return *this; - } - - WriteDescriptorSet& setPImageInfo( const DescriptorImageInfo* pImageInfo_ ) - { - pImageInfo = pImageInfo_; - return *this; - } - - WriteDescriptorSet& setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ ) - { - pBufferInfo = pBufferInfo_; - return *this; - } - - WriteDescriptorSet& setPTexelBufferView( const BufferView* pTexelBufferView_ ) - { - pTexelBufferView = pTexelBufferView_; - return *this; - } - - operator const VkWriteDescriptorSet&() const - { - return *reinterpret_cast<const VkWriteDescriptorSet*>(this); - } - - bool operator==( WriteDescriptorSet const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( dstSet == rhs.dstSet ) - && ( dstBinding == rhs.dstBinding ) - && ( dstArrayElement == rhs.dstArrayElement ) - && ( descriptorCount == rhs.descriptorCount ) - && ( descriptorType == rhs.descriptorType ) - && ( pImageInfo == rhs.pImageInfo ) - && ( pBufferInfo == rhs.pBufferInfo ) - && ( pTexelBufferView == rhs.pTexelBufferView ); - } - - bool operator!=( WriteDescriptorSet const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWriteDescriptorSet; - - public: - const void* pNext = nullptr; - DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - DescriptorType descriptorType; - const DescriptorImageInfo* pImageInfo; - const DescriptorBufferInfo* pBufferInfo; - const BufferView* pTexelBufferView; - }; - static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); - - struct CopyDescriptorSet - { - 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 ) - : srcSet( srcSet_ ) - , srcBinding( srcBinding_ ) - , srcArrayElement( srcArrayElement_ ) - , dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - { - } - - CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); - } - - CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) - { - memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); - return *this; - } - CopyDescriptorSet& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CopyDescriptorSet& setSrcSet( DescriptorSet srcSet_ ) - { - srcSet = srcSet_; - return *this; - } - - CopyDescriptorSet& setSrcBinding( uint32_t srcBinding_ ) - { - srcBinding = srcBinding_; - return *this; - } - - CopyDescriptorSet& setSrcArrayElement( uint32_t srcArrayElement_ ) - { - srcArrayElement = srcArrayElement_; - return *this; - } - - CopyDescriptorSet& setDstSet( DescriptorSet dstSet_ ) - { - dstSet = dstSet_; - return *this; - } - - CopyDescriptorSet& setDstBinding( uint32_t dstBinding_ ) - { - dstBinding = dstBinding_; - return *this; - } - - CopyDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ ) - { - dstArrayElement = dstArrayElement_; - return *this; - } - - CopyDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - operator const VkCopyDescriptorSet&() const - { - return *reinterpret_cast<const VkCopyDescriptorSet*>(this); - } - - bool operator==( CopyDescriptorSet const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcSet == rhs.srcSet ) - && ( srcBinding == rhs.srcBinding ) - && ( srcArrayElement == rhs.srcArrayElement ) - && ( dstSet == rhs.dstSet ) - && ( dstBinding == rhs.dstBinding ) - && ( dstArrayElement == rhs.dstArrayElement ) - && ( descriptorCount == rhs.descriptorCount ); - } - - bool operator!=( CopyDescriptorSet const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCopyDescriptorSet; - - public: - const void* pNext = nullptr; - DescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - }; - static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" ); - - struct BufferViewCreateInfo - { - BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), Buffer buffer_ = Buffer(), Format format_ = Format::eUndefined, DeviceSize offset_ = 0, DeviceSize range_ = 0 ) - : flags( flags_ ) - , buffer( buffer_ ) - , format( format_ ) - , offset( offset_ ) - , range( range_ ) - { - } - - BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); - } - - BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); - return *this; - } - BufferViewCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferViewCreateInfo& setFlags( BufferViewCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - BufferViewCreateInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - BufferViewCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - BufferViewCreateInfo& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - BufferViewCreateInfo& setRange( DeviceSize range_ ) - { - range = range_; - return *this; - } - - operator const VkBufferViewCreateInfo&() const - { - return *reinterpret_cast<const VkBufferViewCreateInfo*>(this); - } - - bool operator==( BufferViewCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ) - && ( format == rhs.format ) - && ( offset == rhs.offset ) - && ( range == rhs.range ); - } - - bool operator!=( BufferViewCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferViewCreateInfo; - - public: - const void* pNext = nullptr; - BufferViewCreateFlags flags; - Buffer buffer; - Format format; - DeviceSize offset; - DeviceSize range; - }; - static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); - - struct ShaderModuleCreateInfo - { - ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr ) - : flags( flags_ ) - , codeSize( codeSize_ ) - , pCode( pCode_ ) - { - } - - ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); - } - - ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); - return *this; - } - ShaderModuleCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ShaderModuleCreateInfo& setFlags( ShaderModuleCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ShaderModuleCreateInfo& setCodeSize( size_t codeSize_ ) - { - codeSize = codeSize_; - return *this; - } - - ShaderModuleCreateInfo& setPCode( const uint32_t* pCode_ ) - { - pCode = pCode_; - return *this; - } - - operator const VkShaderModuleCreateInfo&() const - { - return *reinterpret_cast<const VkShaderModuleCreateInfo*>(this); - } - - bool operator==( ShaderModuleCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( codeSize == rhs.codeSize ) - && ( pCode == rhs.pCode ); - } - - bool operator!=( ShaderModuleCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eShaderModuleCreateInfo; - - public: - const void* pNext = nullptr; - ShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; - }; - static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" ); - - struct DescriptorSetAllocateInfo - { - DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), uint32_t descriptorSetCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr ) - : descriptorPool( descriptorPool_ ) - , descriptorSetCount( descriptorSetCount_ ) - , pSetLayouts( pSetLayouts_ ) - { - } - - DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); - } - - DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); - return *this; - } - DescriptorSetAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorSetAllocateInfo& setDescriptorPool( DescriptorPool descriptorPool_ ) - { - descriptorPool = descriptorPool_; - return *this; - } - - DescriptorSetAllocateInfo& setDescriptorSetCount( uint32_t descriptorSetCount_ ) - { - descriptorSetCount = descriptorSetCount_; - return *this; - } - - DescriptorSetAllocateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) - { - pSetLayouts = pSetLayouts_; - return *this; - } - - operator const VkDescriptorSetAllocateInfo&() const - { - return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(this); - } - - bool operator==( DescriptorSetAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( descriptorPool == rhs.descriptorPool ) - && ( descriptorSetCount == rhs.descriptorSetCount ) - && ( pSetLayouts == rhs.pSetLayouts ); - } - - bool operator!=( DescriptorSetAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetAllocateInfo; - - public: - const void* pNext = nullptr; - DescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const DescriptorSetLayout* pSetLayouts; - }; - static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" ); - - struct PipelineVertexInputStateCreateInfo - { - PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) - : flags( flags_ ) - , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) - , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) - , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) - , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ ) - { - } - - PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); - } - - PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); - return *this; - } - PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setFlags( PipelineVertexInputStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) - { - vertexBindingDescriptionCount = vertexBindingDescriptionCount_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ ) - { - pVertexBindingDescriptions = pVertexBindingDescriptions_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) - { - vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_; - return *this; - } - - PipelineVertexInputStateCreateInfo& setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ ) - { - pVertexAttributeDescriptions = pVertexAttributeDescriptions_; - return *this; - } - - operator const VkPipelineVertexInputStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(this); - } - - bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) - && ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) - && ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) - && ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); - } - - bool operator!=( PipelineVertexInputStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VertexInputAttributeDescription* pVertexAttributeDescriptions; - }; - static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineInputAssemblyStateCreateInfo - { - PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), PrimitiveTopology topology_ = PrimitiveTopology::ePointList, Bool32 primitiveRestartEnable_ = 0 ) - : flags( flags_ ) - , topology( topology_ ) - , primitiveRestartEnable( primitiveRestartEnable_ ) - { - } - - PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); - } - - PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); - return *this; - } - PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineInputAssemblyStateCreateInfo& setFlags( PipelineInputAssemblyStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineInputAssemblyStateCreateInfo& setTopology( PrimitiveTopology topology_ ) - { - topology = topology_; - return *this; - } - - PipelineInputAssemblyStateCreateInfo& setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ ) - { - primitiveRestartEnable = primitiveRestartEnable_; - return *this; - } - - operator const VkPipelineInputAssemblyStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(this); - } - - bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( topology == rhs.topology ) - && ( primitiveRestartEnable == rhs.primitiveRestartEnable ); - } - - bool operator!=( PipelineInputAssemblyStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineInputAssemblyStateCreateFlags flags; - PrimitiveTopology topology; - Bool32 primitiveRestartEnable; - }; - static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineTessellationStateCreateInfo - { - PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 ) - : flags( flags_ ) - , patchControlPoints( patchControlPoints_ ) - { - } - - PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); - } - - PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); - return *this; - } - PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineTessellationStateCreateInfo& setFlags( PipelineTessellationStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineTessellationStateCreateInfo& setPatchControlPoints( uint32_t patchControlPoints_ ) - { - patchControlPoints = patchControlPoints_; - return *this; - } - - operator const VkPipelineTessellationStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(this); - } - - bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( patchControlPoints == rhs.patchControlPoints ); - } - - bool operator!=( PipelineTessellationStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; - }; - static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineViewportStateCreateInfo - { - PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const Rect2D* pScissors_ = nullptr ) - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewports( pViewports_ ) - , scissorCount( scissorCount_ ) - , pScissors( pScissors_ ) - { - } - - PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); - } - - PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); - return *this; - } - PipelineViewportStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineViewportStateCreateInfo& setFlags( PipelineViewportStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineViewportStateCreateInfo& setViewportCount( uint32_t viewportCount_ ) - { - viewportCount = viewportCount_; - return *this; - } - - PipelineViewportStateCreateInfo& setPViewports( const Viewport* pViewports_ ) - { - pViewports = pViewports_; - return *this; - } - - PipelineViewportStateCreateInfo& setScissorCount( uint32_t scissorCount_ ) - { - scissorCount = scissorCount_; - return *this; - } - - PipelineViewportStateCreateInfo& setPScissors( const Rect2D* pScissors_ ) - { - pScissors = pScissors_; - return *this; - } - - operator const VkPipelineViewportStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(this); - } - - bool operator==( PipelineViewportStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( viewportCount == rhs.viewportCount ) - && ( pViewports == rhs.pViewports ) - && ( scissorCount == rhs.scissorCount ) - && ( pScissors == rhs.pScissors ); - } - - bool operator!=( PipelineViewportStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineViewportStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const Viewport* pViewports; - uint32_t scissorCount; - const Rect2D* pScissors; - }; - static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineRasterizationStateCreateInfo - { - 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 ) - : flags( flags_ ) - , depthClampEnable( depthClampEnable_ ) - , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) - , polygonMode( polygonMode_ ) - , cullMode( cullMode_ ) - , frontFace( frontFace_ ) - , depthBiasEnable( depthBiasEnable_ ) - , depthBiasConstantFactor( depthBiasConstantFactor_ ) - , depthBiasClamp( depthBiasClamp_ ) - , depthBiasSlopeFactor( depthBiasSlopeFactor_ ) - , lineWidth( lineWidth_ ) - { - } - - PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); - } - - PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); - return *this; - } - PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setFlags( PipelineRasterizationStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthClampEnable( Bool32 depthClampEnable_ ) - { - depthClampEnable = depthClampEnable_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ ) - { - rasterizerDiscardEnable = rasterizerDiscardEnable_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setPolygonMode( PolygonMode polygonMode_ ) - { - polygonMode = polygonMode_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setCullMode( CullModeFlags cullMode_ ) - { - cullMode = cullMode_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setFrontFace( FrontFace frontFace_ ) - { - frontFace = frontFace_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasEnable( Bool32 depthBiasEnable_ ) - { - depthBiasEnable = depthBiasEnable_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) - { - depthBiasConstantFactor = depthBiasConstantFactor_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasClamp( float depthBiasClamp_ ) - { - depthBiasClamp = depthBiasClamp_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) - { - depthBiasSlopeFactor = depthBiasSlopeFactor_; - return *this; - } - - PipelineRasterizationStateCreateInfo& setLineWidth( float lineWidth_ ) - { - lineWidth = lineWidth_; - return *this; - } - - operator const VkPipelineRasterizationStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(this); - } - - bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( depthClampEnable == rhs.depthClampEnable ) - && ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) - && ( polygonMode == rhs.polygonMode ) - && ( cullMode == rhs.cullMode ) - && ( frontFace == rhs.frontFace ) - && ( depthBiasEnable == rhs.depthBiasEnable ) - && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) - && ( depthBiasClamp == rhs.depthBiasClamp ) - && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) - && ( lineWidth == rhs.lineWidth ); - } - - bool operator!=( PipelineRasterizationStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineRasterizationStateCreateFlags flags; - Bool32 depthClampEnable; - Bool32 rasterizerDiscardEnable; - PolygonMode polygonMode; - CullModeFlags cullMode; - FrontFace frontFace; - Bool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; - }; - static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineDepthStencilStateCreateInfo - { - 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 ) - : flags( flags_ ) - , depthTestEnable( depthTestEnable_ ) - , depthWriteEnable( depthWriteEnable_ ) - , depthCompareOp( depthCompareOp_ ) - , depthBoundsTestEnable( depthBoundsTestEnable_ ) - , stencilTestEnable( stencilTestEnable_ ) - , front( front_ ) - , back( back_ ) - , minDepthBounds( minDepthBounds_ ) - , maxDepthBounds( maxDepthBounds_ ) - { - } - - PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); - } - - PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); - return *this; - } - PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setFlags( PipelineDepthStencilStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthTestEnable( Bool32 depthTestEnable_ ) - { - depthTestEnable = depthTestEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthWriteEnable( Bool32 depthWriteEnable_ ) - { - depthWriteEnable = depthWriteEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthCompareOp( CompareOp depthCompareOp_ ) - { - depthCompareOp = depthCompareOp_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ ) - { - depthBoundsTestEnable = depthBoundsTestEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setStencilTestEnable( Bool32 stencilTestEnable_ ) - { - stencilTestEnable = stencilTestEnable_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setFront( StencilOpState front_ ) - { - front = front_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setBack( StencilOpState back_ ) - { - back = back_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setMinDepthBounds( float minDepthBounds_ ) - { - minDepthBounds = minDepthBounds_; - return *this; - } - - PipelineDepthStencilStateCreateInfo& setMaxDepthBounds( float maxDepthBounds_ ) - { - maxDepthBounds = maxDepthBounds_; - return *this; - } - - operator const VkPipelineDepthStencilStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(this); - } - - bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( depthTestEnable == rhs.depthTestEnable ) - && ( depthWriteEnable == rhs.depthWriteEnable ) - && ( depthCompareOp == rhs.depthCompareOp ) - && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) - && ( stencilTestEnable == rhs.stencilTestEnable ) - && ( front == rhs.front ) - && ( back == rhs.back ) - && ( minDepthBounds == rhs.minDepthBounds ) - && ( maxDepthBounds == rhs.maxDepthBounds ); - } - - bool operator!=( PipelineDepthStencilStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineDepthStencilStateCreateFlags flags; - Bool32 depthTestEnable; - Bool32 depthWriteEnable; - CompareOp depthCompareOp; - Bool32 depthBoundsTestEnable; - Bool32 stencilTestEnable; - StencilOpState front; - StencilOpState back; - float minDepthBounds; - float maxDepthBounds; - }; - static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineCacheCreateInfo - { - PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - { - } - - PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); - } - - PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); - return *this; - } - PipelineCacheCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineCacheCreateInfo& setFlags( PipelineCacheCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineCacheCreateInfo& setInitialDataSize( size_t initialDataSize_ ) - { - initialDataSize = initialDataSize_; - return *this; - } - - PipelineCacheCreateInfo& setPInitialData( const void* pInitialData_ ) - { - pInitialData = pInitialData_; - return *this; - } - - operator const VkPipelineCacheCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineCacheCreateInfo*>(this); - } - - bool operator==( PipelineCacheCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( initialDataSize == rhs.initialDataSize ) - && ( pInitialData == rhs.pInitialData ); - } - - bool operator!=( PipelineCacheCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineCacheCreateInfo; - - public: - const void* pNext = nullptr; - PipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" ); - - struct SamplerCreateInfo - { - 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 ) - : flags( flags_ ) - , magFilter( magFilter_ ) - , minFilter( minFilter_ ) - , mipmapMode( mipmapMode_ ) - , addressModeU( addressModeU_ ) - , addressModeV( addressModeV_ ) - , addressModeW( addressModeW_ ) - , mipLodBias( mipLodBias_ ) - , anisotropyEnable( anisotropyEnable_ ) - , maxAnisotropy( maxAnisotropy_ ) - , compareEnable( compareEnable_ ) - , compareOp( compareOp_ ) - , minLod( minLod_ ) - , maxLod( maxLod_ ) - , borderColor( borderColor_ ) - , unnormalizedCoordinates( unnormalizedCoordinates_ ) - { - } - - SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); - } - - SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); - return *this; - } - SamplerCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - SamplerCreateInfo& setMagFilter( Filter magFilter_ ) - { - magFilter = magFilter_; - return *this; - } - - SamplerCreateInfo& setMinFilter( Filter minFilter_ ) - { - minFilter = minFilter_; - return *this; - } - - SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ ) - { - mipmapMode = mipmapMode_; - return *this; - } - - SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ ) - { - addressModeU = addressModeU_; - return *this; - } - - SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ ) - { - addressModeV = addressModeV_; - return *this; - } - - SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ ) - { - addressModeW = addressModeW_; - return *this; - } - - SamplerCreateInfo& setMipLodBias( float mipLodBias_ ) - { - mipLodBias = mipLodBias_; - return *this; - } - - SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ ) - { - anisotropyEnable = anisotropyEnable_; - return *this; - } - - SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ ) - { - maxAnisotropy = maxAnisotropy_; - return *this; - } - - SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ ) - { - compareEnable = compareEnable_; - return *this; - } - - SamplerCreateInfo& setCompareOp( CompareOp compareOp_ ) - { - compareOp = compareOp_; - return *this; - } - - SamplerCreateInfo& setMinLod( float minLod_ ) - { - minLod = minLod_; - return *this; - } - - SamplerCreateInfo& setMaxLod( float maxLod_ ) - { - maxLod = maxLod_; - return *this; - } - - SamplerCreateInfo& setBorderColor( BorderColor borderColor_ ) - { - borderColor = borderColor_; - return *this; - } - - SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) - { - unnormalizedCoordinates = unnormalizedCoordinates_; - return *this; - } - - operator const VkSamplerCreateInfo&() const - { - return *reinterpret_cast<const VkSamplerCreateInfo*>(this); - } - - bool operator==( SamplerCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( magFilter == rhs.magFilter ) - && ( minFilter == rhs.minFilter ) - && ( mipmapMode == rhs.mipmapMode ) - && ( addressModeU == rhs.addressModeU ) - && ( addressModeV == rhs.addressModeV ) - && ( addressModeW == rhs.addressModeW ) - && ( mipLodBias == rhs.mipLodBias ) - && ( anisotropyEnable == rhs.anisotropyEnable ) - && ( maxAnisotropy == rhs.maxAnisotropy ) - && ( compareEnable == rhs.compareEnable ) - && ( compareOp == rhs.compareOp ) - && ( minLod == rhs.minLod ) - && ( maxLod == rhs.maxLod ) - && ( borderColor == rhs.borderColor ) - && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); - } - - bool operator!=( SamplerCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerCreateInfo; - - public: - const void* pNext = nullptr; - SamplerCreateFlags flags; - Filter magFilter; - Filter minFilter; - SamplerMipmapMode mipmapMode; - SamplerAddressMode addressModeU; - SamplerAddressMode addressModeV; - SamplerAddressMode addressModeW; - float mipLodBias; - Bool32 anisotropyEnable; - float maxAnisotropy; - Bool32 compareEnable; - CompareOp compareOp; - float minLod; - float maxLod; - BorderColor borderColor; - Bool32 unnormalizedCoordinates; - }; - static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); - - struct CommandBufferAllocateInfo - { - CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), CommandBufferLevel level_ = CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 ) - : commandPool( commandPool_ ) - , level( level_ ) - , commandBufferCount( commandBufferCount_ ) - { - } - - CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); - } - - CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); - return *this; - } - CommandBufferAllocateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandBufferAllocateInfo& setCommandPool( CommandPool commandPool_ ) - { - commandPool = commandPool_; - return *this; - } - - CommandBufferAllocateInfo& setLevel( CommandBufferLevel level_ ) - { - level = level_; - return *this; - } - - CommandBufferAllocateInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) - { - commandBufferCount = commandBufferCount_; - return *this; - } - - operator const VkCommandBufferAllocateInfo&() const - { - return *reinterpret_cast<const VkCommandBufferAllocateInfo*>(this); - } - - bool operator==( CommandBufferAllocateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( commandPool == rhs.commandPool ) - && ( level == rhs.level ) - && ( commandBufferCount == rhs.commandBufferCount ); - } - - bool operator!=( CommandBufferAllocateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandBufferAllocateInfo; - - public: - const void* pNext = nullptr; - CommandPool commandPool; - CommandBufferLevel level; - uint32_t commandBufferCount; - }; - static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" ); - - struct RenderPassBeginInfo - { - RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), Framebuffer framebuffer_ = Framebuffer(), Rect2D renderArea_ = Rect2D(), uint32_t clearValueCount_ = 0, const ClearValue* pClearValues_ = nullptr ) - : renderPass( renderPass_ ) - , framebuffer( framebuffer_ ) - , renderArea( renderArea_ ) - , clearValueCount( clearValueCount_ ) - , pClearValues( pClearValues_ ) - { - } - - RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); - } - - RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); - return *this; - } - RenderPassBeginInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassBeginInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - RenderPassBeginInfo& setFramebuffer( Framebuffer framebuffer_ ) - { - framebuffer = framebuffer_; - return *this; - } - - RenderPassBeginInfo& setRenderArea( Rect2D renderArea_ ) - { - renderArea = renderArea_; - return *this; - } - - RenderPassBeginInfo& setClearValueCount( uint32_t clearValueCount_ ) - { - clearValueCount = clearValueCount_; - return *this; - } - - RenderPassBeginInfo& setPClearValues( const ClearValue* pClearValues_ ) - { - pClearValues = pClearValues_; - return *this; - } - - operator const VkRenderPassBeginInfo&() const - { - return *reinterpret_cast<const VkRenderPassBeginInfo*>(this); - } - - bool operator==( RenderPassBeginInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( renderPass == rhs.renderPass ) - && ( framebuffer == rhs.framebuffer ) - && ( renderArea == rhs.renderArea ) - && ( clearValueCount == rhs.clearValueCount ) - && ( pClearValues == rhs.pClearValues ); - } - - bool operator!=( RenderPassBeginInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassBeginInfo; - - public: - const void* pNext = nullptr; - RenderPass renderPass; - Framebuffer framebuffer; - Rect2D renderArea; - uint32_t clearValueCount; - const ClearValue* pClearValues; - }; - static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); - - struct EventCreateInfo - { - EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() ) - : flags( flags_ ) - { - } - - EventCreateInfo( VkEventCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( EventCreateInfo ) ); - } - - EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( EventCreateInfo ) ); - return *this; - } - EventCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - EventCreateInfo& setFlags( EventCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkEventCreateInfo&() const - { - return *reinterpret_cast<const VkEventCreateInfo*>(this); - } - - bool operator==( EventCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ); - } - - bool operator!=( EventCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eEventCreateInfo; - - public: - const void* pNext = nullptr; - EventCreateFlags flags; - }; - static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); - - struct SemaphoreCreateInfo - { - SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() ) - : flags( flags_ ) - { - } - - SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); - } - - SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); - return *this; - } - SemaphoreCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SemaphoreCreateInfo& setFlags( SemaphoreCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkSemaphoreCreateInfo&() const - { - return *reinterpret_cast<const VkSemaphoreCreateInfo*>(this); - } - - bool operator==( SemaphoreCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ); - } - - bool operator!=( SemaphoreCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSemaphoreCreateInfo; - - public: - const void* pNext = nullptr; - SemaphoreCreateFlags flags; - }; - static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); - - struct FramebufferCreateInfo - { - 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 ) - : flags( flags_ ) - , renderPass( renderPass_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , width( width_ ) - , height( height_ ) - , layers( layers_ ) - { - } - - FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); - } - - FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); - return *this; - } - FramebufferCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FramebufferCreateInfo& setFlags( FramebufferCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - FramebufferCreateInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - FramebufferCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) - { - attachmentCount = attachmentCount_; - return *this; - } - - FramebufferCreateInfo& setPAttachments( const ImageView* pAttachments_ ) - { - pAttachments = pAttachments_; - return *this; - } - - FramebufferCreateInfo& setWidth( uint32_t width_ ) - { - width = width_; - return *this; - } - - FramebufferCreateInfo& setHeight( uint32_t height_ ) - { - height = height_; - return *this; - } - - FramebufferCreateInfo& setLayers( uint32_t layers_ ) - { - layers = layers_; - return *this; - } - - operator const VkFramebufferCreateInfo&() const - { - return *reinterpret_cast<const VkFramebufferCreateInfo*>(this); - } - - bool operator==( FramebufferCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( renderPass == rhs.renderPass ) - && ( attachmentCount == rhs.attachmentCount ) - && ( pAttachments == rhs.pAttachments ) - && ( width == rhs.width ) - && ( height == rhs.height ) - && ( layers == rhs.layers ); - } - - bool operator!=( FramebufferCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFramebufferCreateInfo; - - public: - const void* pNext = nullptr; - FramebufferCreateFlags flags; - RenderPass renderPass; - uint32_t attachmentCount; - const ImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; - }; - static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" ); - - struct DisplayModeCreateInfoKHR - { - DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() ) - : flags( flags_ ) - , parameters( parameters_ ) - { - } - - DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); - } - - DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); - return *this; - } - DisplayModeCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayModeCreateInfoKHR& setFlags( DisplayModeCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - DisplayModeCreateInfoKHR& setParameters( DisplayModeParametersKHR parameters_ ) - { - parameters = parameters_; - return *this; - } - - operator const VkDisplayModeCreateInfoKHR&() const - { - return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(this); - } - - bool operator==( DisplayModeCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( parameters == rhs.parameters ); - } - - bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayModeCreateInfoKHR; - - public: - const void* pNext = nullptr; - DisplayModeCreateFlagsKHR flags; - DisplayModeParametersKHR parameters; - }; - static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct DisplayPresentInfoKHR - { - DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), Rect2D dstRect_ = Rect2D(), Bool32 persistent_ = 0 ) - : srcRect( srcRect_ ) - , dstRect( dstRect_ ) - , persistent( persistent_ ) - { - } - - DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); - } - - DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); - return *this; - } - DisplayPresentInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayPresentInfoKHR& setSrcRect( Rect2D srcRect_ ) - { - srcRect = srcRect_; - return *this; - } - - DisplayPresentInfoKHR& setDstRect( Rect2D dstRect_ ) - { - dstRect = dstRect_; - return *this; - } - - DisplayPresentInfoKHR& setPersistent( Bool32 persistent_ ) - { - persistent = persistent_; - return *this; - } - - operator const VkDisplayPresentInfoKHR&() const - { - return *reinterpret_cast<const VkDisplayPresentInfoKHR*>(this); - } - - bool operator==( DisplayPresentInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcRect == rhs.srcRect ) - && ( dstRect == rhs.dstRect ) - && ( persistent == rhs.persistent ); - } - - bool operator!=( DisplayPresentInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayPresentInfoKHR; - - public: - const void* pNext = nullptr; - Rect2D srcRect; - Rect2D dstRect; - Bool32 persistent; - }; - static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - struct AndroidSurfaceCreateInfoKHR - { - AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), ANativeWindow* window_ = nullptr ) - : flags( flags_ ) - , window( window_ ) - { - } - - AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); - } - - AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); - return *this; - } - AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - AndroidSurfaceCreateInfoKHR& setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - AndroidSurfaceCreateInfoKHR& setWindow( ANativeWindow* window_ ) - { - window = window_; - return *this; - } - - operator const VkAndroidSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(this); - } - - bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( window == rhs.window ); - } - - bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - AndroidSurfaceCreateFlagsKHR flags; - ANativeWindow* window; - }; - static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - struct MirSurfaceCreateInfoKHR - { - MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), MirConnection* connection_ = nullptr, MirSurface* mirSurface_ = nullptr ) - : flags( flags_ ) - , connection( connection_ ) - , mirSurface( mirSurface_ ) - { - } - - MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); - } - - MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); - return *this; - } - MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MirSurfaceCreateInfoKHR& setFlags( MirSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - MirSurfaceCreateInfoKHR& setConnection( MirConnection* connection_ ) - { - connection = connection_; - return *this; - } - - MirSurfaceCreateInfoKHR& setMirSurface( MirSurface* mirSurface_ ) - { - mirSurface = mirSurface_; - return *this; - } - - operator const VkMirSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>(this); - } - - bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( connection == rhs.connection ) - && ( mirSurface == rhs.mirSurface ); - } - - bool operator!=( MirSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMirSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - MirSurfaceCreateFlagsKHR flags; - MirConnection* connection; - MirSurface* mirSurface; - }; - static_assert( sizeof( MirSurfaceCreateInfoKHR ) == sizeof( VkMirSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_VI_NN - struct ViSurfaceCreateInfoNN - { - ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(), void* window_ = nullptr ) - : flags( flags_ ) - , window( window_ ) - { - } - - ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) - { - memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); - } - - ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) - { - memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); - return *this; - } - ViSurfaceCreateInfoNN& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ViSurfaceCreateInfoNN& setFlags( ViSurfaceCreateFlagsNN flags_ ) - { - flags = flags_; - return *this; - } - - ViSurfaceCreateInfoNN& setWindow( void* window_ ) - { - window = window_; - return *this; - } - - operator const VkViSurfaceCreateInfoNN&() const - { - return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>(this); - } - - bool operator==( ViSurfaceCreateInfoNN const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( window == rhs.window ); - } - - bool operator!=( ViSurfaceCreateInfoNN const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eViSurfaceCreateInfoNN; - - public: - const void* pNext = nullptr; - ViSurfaceCreateFlagsNN flags; - void* window; - }; - static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - struct WaylandSurfaceCreateInfoKHR - { - WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr ) - : flags( flags_ ) - , display( display_ ) - , surface( surface_ ) - { - } - - WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); - } - - WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); - return *this; - } - WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - WaylandSurfaceCreateInfoKHR& setFlags( WaylandSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - WaylandSurfaceCreateInfoKHR& setDisplay( struct wl_display* display_ ) - { - display = display_; - return *this; - } - - WaylandSurfaceCreateInfoKHR& setSurface( struct wl_surface* surface_ ) - { - surface = surface_; - return *this; - } - - operator const VkWaylandSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(this); - } - - bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( display == rhs.display ) - && ( surface == rhs.surface ); - } - - bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - WaylandSurfaceCreateFlagsKHR flags; - struct wl_display* display; - struct wl_surface* surface; - }; - static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct Win32SurfaceCreateInfoKHR - { - Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 ) - : flags( flags_ ) - , hinstance( hinstance_ ) - , hwnd( hwnd_ ) - { - } - - Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); - } - - Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); - return *this; - } - Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - Win32SurfaceCreateInfoKHR& setFlags( Win32SurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - Win32SurfaceCreateInfoKHR& setHinstance( HINSTANCE hinstance_ ) - { - hinstance = hinstance_; - return *this; - } - - Win32SurfaceCreateInfoKHR& setHwnd( HWND hwnd_ ) - { - hwnd = hwnd_; - return *this; - } - - operator const VkWin32SurfaceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(this); - } - - bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( hinstance == rhs.hinstance ) - && ( hwnd == rhs.hwnd ); - } - - bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - Win32SurfaceCreateFlagsKHR flags; - HINSTANCE hinstance; - HWND hwnd; - }; - static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - struct XlibSurfaceCreateInfoKHR - { - XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 ) - : flags( flags_ ) - , dpy( dpy_ ) - , window( window_ ) - { - } - - XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); - } - - XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); - return *this; - } - XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - XlibSurfaceCreateInfoKHR& setFlags( XlibSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - XlibSurfaceCreateInfoKHR& setDpy( Display* dpy_ ) - { - dpy = dpy_; - return *this; - } - - XlibSurfaceCreateInfoKHR& setWindow( Window window_ ) - { - window = window_; - return *this; - } - - operator const VkXlibSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(this); - } - - bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( dpy == rhs.dpy ) - && ( window == rhs.window ); - } - - bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - XlibSurfaceCreateFlagsKHR flags; - Display* dpy; - Window window; - }; - static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - struct XcbSurfaceCreateInfoKHR - { - XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 ) - : flags( flags_ ) - , connection( connection_ ) - , window( window_ ) - { - } - - XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); - } - - XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); - return *this; - } - XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - XcbSurfaceCreateInfoKHR& setFlags( XcbSurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - XcbSurfaceCreateInfoKHR& setConnection( xcb_connection_t* connection_ ) - { - connection = connection_; - return *this; - } - - XcbSurfaceCreateInfoKHR& setWindow( xcb_window_t window_ ) - { - window = window_; - return *this; - } - - operator const VkXcbSurfaceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(this); - } - - bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( connection == rhs.connection ) - && ( window == rhs.window ); - } - - bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - XcbSurfaceCreateFlagsKHR flags; - xcb_connection_t* connection; - xcb_window_t window; - }; - static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - struct DebugMarkerMarkerInfoEXT - { - DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } ) - : pMarkerName( pMarkerName_ ) - { - memcpy( &color, color_.data(), 4 * sizeof( float ) ); - } - - DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); - } - - DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); - return *this; - } - DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugMarkerMarkerInfoEXT& setPMarkerName( const char* pMarkerName_ ) - { - pMarkerName = pMarkerName_; - return *this; - } - - DebugMarkerMarkerInfoEXT& setColor( std::array<float,4> color_ ) - { - memcpy( &color, color_.data(), 4 * sizeof( float ) ); - return *this; - } - - operator const VkDebugMarkerMarkerInfoEXT&() const - { - return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(this); - } - - bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pMarkerName == rhs.pMarkerName ) - && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 ); - } - - bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; - - public: - const void* pNext = nullptr; - const char* pMarkerName; - float color[4]; - }; - static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" ); - - struct DedicatedAllocationImageCreateInfoNV - { - DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) - : dedicatedAllocation( dedicatedAllocation_ ) - { - } - - DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); - } - - DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); - return *this; - } - DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DedicatedAllocationImageCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ ) - { - dedicatedAllocation = dedicatedAllocation_; - return *this; - } - - operator const VkDedicatedAllocationImageCreateInfoNV&() const - { - return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(this); - } - - bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( dedicatedAllocation == rhs.dedicatedAllocation ); - } - - bool operator!=( DedicatedAllocationImageCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; - - public: - const void* pNext = nullptr; - Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" ); - - struct DedicatedAllocationBufferCreateInfoNV - { - DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 ) - : dedicatedAllocation( dedicatedAllocation_ ) - { - } - - DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); - } - - DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); - return *this; - } - DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DedicatedAllocationBufferCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ ) - { - dedicatedAllocation = dedicatedAllocation_; - return *this; - } - - operator const VkDedicatedAllocationBufferCreateInfoNV&() const - { - return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(this); - } - - bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( dedicatedAllocation == rhs.dedicatedAllocation ); - } - - bool operator!=( DedicatedAllocationBufferCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; - - public: - const void* pNext = nullptr; - Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" ); - - struct DedicatedAllocationMemoryAllocateInfoNV - { - DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), Buffer buffer_ = Buffer() ) - : image( image_ ) - , buffer( buffer_ ) - { - } - - DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); - } - - DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); - return *this; - } - DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DedicatedAllocationMemoryAllocateInfoNV& setImage( Image image_ ) - { - image = image_; - return *this; - } - - DedicatedAllocationMemoryAllocateInfoNV& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkDedicatedAllocationMemoryAllocateInfoNV&() const - { - return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(this); - } - - bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; - - public: - const void* pNext = nullptr; - Image image; - Buffer buffer; - }; - static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ExportMemoryWin32HandleInfoNV - { - ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - { - } - - ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); - } - - ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); - return *this; - } - ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - operator const VkExportMemoryWin32HandleInfoNV&() const - { - return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this); - } - - bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ); - } - - bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct Win32KeyedMutexAcquireReleaseInfoNV - { - Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - { - } - - Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); - } - - Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); - return *this; - } - Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ ) - { - acquireCount = acquireCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) - { - pAcquireSyncs = pAcquireSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) - { - pAcquireKeys = pAcquireKeys_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ ) - { - pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ ) - { - releaseCount = releaseCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) - { - pReleaseSyncs = pReleaseSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) - { - pReleaseKeys = pReleaseKeys_; - return *this; - } - - operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const - { - return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this); - } - - bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( acquireCount == rhs.acquireCount ) - && ( pAcquireSyncs == rhs.pAcquireSyncs ) - && ( pAcquireKeys == rhs.pAcquireKeys ) - && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) - && ( releaseCount == rhs.releaseCount ) - && ( pReleaseSyncs == rhs.pReleaseSyncs ) - && ( pReleaseKeys == rhs.pReleaseKeys ); - } - - bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; - - public: - const void* pNext = nullptr; - uint32_t acquireCount; - const DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeoutMilliseconds; - uint32_t releaseCount; - const DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct DeviceGeneratedCommandsFeaturesNVX - { - DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 ) - : computeBindingPointSupport( computeBindingPointSupport_ ) - { - } - - DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); - } - - DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); - return *this; - } - DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGeneratedCommandsFeaturesNVX& setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ ) - { - computeBindingPointSupport = computeBindingPointSupport_; - return *this; - } - - operator const VkDeviceGeneratedCommandsFeaturesNVX&() const - { - return *reinterpret_cast<const VkDeviceGeneratedCommandsFeaturesNVX*>(this); - } - - bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( computeBindingPointSupport == rhs.computeBindingPointSupport ); - } - - bool operator!=( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; - - public: - const void* pNext = nullptr; - Bool32 computeBindingPointSupport; - }; - static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" ); - - struct DeviceGeneratedCommandsLimitsNVX - { - DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, uint32_t maxObjectEntryCounts_ = 0, uint32_t minSequenceCountBufferOffsetAlignment_ = 0, uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) - : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) - , maxObjectEntryCounts( maxObjectEntryCounts_ ) - , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) - , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) - , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ ) - { - } - - DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); - } - - DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); - return *this; - } - DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMaxIndirectCommandsLayoutTokenCount( uint32_t maxIndirectCommandsLayoutTokenCount_ ) - { - maxIndirectCommandsLayoutTokenCount = maxIndirectCommandsLayoutTokenCount_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMaxObjectEntryCounts( uint32_t maxObjectEntryCounts_ ) - { - maxObjectEntryCounts = maxObjectEntryCounts_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMinSequenceCountBufferOffsetAlignment( uint32_t minSequenceCountBufferOffsetAlignment_ ) - { - minSequenceCountBufferOffsetAlignment = minSequenceCountBufferOffsetAlignment_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMinSequenceIndexBufferOffsetAlignment( uint32_t minSequenceIndexBufferOffsetAlignment_ ) - { - minSequenceIndexBufferOffsetAlignment = minSequenceIndexBufferOffsetAlignment_; - return *this; - } - - DeviceGeneratedCommandsLimitsNVX& setMinCommandsTokenBufferOffsetAlignment( uint32_t minCommandsTokenBufferOffsetAlignment_ ) - { - minCommandsTokenBufferOffsetAlignment = minCommandsTokenBufferOffsetAlignment_; - return *this; - } - - operator const VkDeviceGeneratedCommandsLimitsNVX&() const - { - return *reinterpret_cast<const VkDeviceGeneratedCommandsLimitsNVX*>(this); - } - - bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxIndirectCommandsLayoutTokenCount == rhs.maxIndirectCommandsLayoutTokenCount ) - && ( maxObjectEntryCounts == rhs.maxObjectEntryCounts ) - && ( minSequenceCountBufferOffsetAlignment == rhs.minSequenceCountBufferOffsetAlignment ) - && ( minSequenceIndexBufferOffsetAlignment == rhs.minSequenceIndexBufferOffsetAlignment ) - && ( minCommandsTokenBufferOffsetAlignment == rhs.minCommandsTokenBufferOffsetAlignment ); - } - - bool operator!=( DeviceGeneratedCommandsLimitsNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; - - public: - const void* pNext = nullptr; - uint32_t maxIndirectCommandsLayoutTokenCount; - uint32_t maxObjectEntryCounts; - uint32_t minSequenceCountBufferOffsetAlignment; - uint32_t minSequenceIndexBufferOffsetAlignment; - uint32_t minCommandsTokenBufferOffsetAlignment; - }; - static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" ); - - struct CmdReserveSpaceForCommandsInfoNVX - { - CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_ = 0 ) - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , maxSequencesCount( maxSequencesCount_ ) - { - } - - CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); - } - - CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); - return *this; - } - CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CmdReserveSpaceForCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ ) - { - objectTable = objectTable_; - return *this; - } - - CmdReserveSpaceForCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ ) - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - CmdReserveSpaceForCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ ) - { - maxSequencesCount = maxSequencesCount_; - return *this; - } - - operator const VkCmdReserveSpaceForCommandsInfoNVX&() const - { - return *reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>(this); - } - - bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectTable == rhs.objectTable ) - && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) - && ( maxSequencesCount == rhs.maxSequencesCount ); - } - - bool operator!=( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; - - public: - const void* pNext = nullptr; - ObjectTableNVX objectTable; - IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t maxSequencesCount; - }; - static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceFeatures2KHR - { - PhysicalDeviceFeatures2KHR( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() ) - : features( features_ ) - { - } - - PhysicalDeviceFeatures2KHR( VkPhysicalDeviceFeatures2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) ); - } - - PhysicalDeviceFeatures2KHR& operator=( VkPhysicalDeviceFeatures2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) ); - return *this; - } - PhysicalDeviceFeatures2KHR& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceFeatures2KHR& setFeatures( PhysicalDeviceFeatures features_ ) - { - features = features_; - return *this; - } - - operator const VkPhysicalDeviceFeatures2KHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceFeatures2KHR*>(this); - } - - bool operator==( PhysicalDeviceFeatures2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( features == rhs.features ); - } - - bool operator!=( PhysicalDeviceFeatures2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceFeatures2KHR; - - public: - void* pNext = nullptr; - PhysicalDeviceFeatures features; - }; - static_assert( sizeof( PhysicalDeviceFeatures2KHR ) == sizeof( VkPhysicalDeviceFeatures2KHR ), "struct and wrapper have different size!" ); - - struct PhysicalDevicePushDescriptorPropertiesKHR - { - PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 ) - : maxPushDescriptors( maxPushDescriptors_ ) - { - } - - PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); - } - - PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); - return *this; - } - PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDevicePushDescriptorPropertiesKHR& setMaxPushDescriptors( uint32_t maxPushDescriptors_ ) - { - maxPushDescriptors = maxPushDescriptors_; - return *this; - } - - operator const VkPhysicalDevicePushDescriptorPropertiesKHR&() const - { - return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(this); - } - - bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxPushDescriptors == rhs.maxPushDescriptors ); - } - - bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; - - public: - void* pNext = nullptr; - uint32_t maxPushDescriptors; - }; - static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" ); - - struct PresentRegionsKHR - { - PresentRegionsKHR( uint32_t swapchainCount_ = 0, const PresentRegionKHR* pRegions_ = nullptr ) - : swapchainCount( swapchainCount_ ) - , pRegions( pRegions_ ) - { - } - - PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); - } - - PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); - return *this; - } - PresentRegionsKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PresentRegionsKHR& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - PresentRegionsKHR& setPRegions( const PresentRegionKHR* pRegions_ ) - { - pRegions = pRegions_; - return *this; - } - - operator const VkPresentRegionsKHR&() const - { - return *reinterpret_cast<const VkPresentRegionsKHR*>(this); - } - - bool operator==( PresentRegionsKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pRegions == rhs.pRegions ); - } - - bool operator!=( PresentRegionsKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePresentRegionsKHR; - - public: - const void* pNext = nullptr; - uint32_t swapchainCount; - const PresentRegionKHR* pRegions; - }; - static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceVariablePointerFeaturesKHR - { - PhysicalDeviceVariablePointerFeaturesKHR( Bool32 variablePointersStorageBuffer_ = 0, Bool32 variablePointers_ = 0 ) - : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) - , variablePointers( variablePointers_ ) - { - } - - PhysicalDeviceVariablePointerFeaturesKHR( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) ); - } - - PhysicalDeviceVariablePointerFeaturesKHR& operator=( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) ); - return *this; - } - PhysicalDeviceVariablePointerFeaturesKHR& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) - { - variablePointersStorageBuffer = variablePointersStorageBuffer_; - return *this; - } - - PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointers( Bool32 variablePointers_ ) - { - variablePointers = variablePointers_; - return *this; - } - - operator const VkPhysicalDeviceVariablePointerFeaturesKHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceVariablePointerFeaturesKHR*>(this); - } - - bool operator==( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) - && ( variablePointers == rhs.variablePointers ); - } - - bool operator!=( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeaturesKHR; - - public: - void* pNext = nullptr; - Bool32 variablePointersStorageBuffer; - Bool32 variablePointers; - }; - static_assert( sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) == sizeof( VkPhysicalDeviceVariablePointerFeaturesKHR ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceIDPropertiesKHR - { - operator const VkPhysicalDeviceIDPropertiesKHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceIDPropertiesKHR*>(this); - } - - bool operator==( PhysicalDeviceIDPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE_KHR * sizeof( uint8_t ) ) == 0 ) - && ( deviceNodeMask == rhs.deviceNodeMask ) - && ( deviceLUIDValid == rhs.deviceLUIDValid ); - } - - bool operator!=( PhysicalDeviceIDPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceIdPropertiesKHR; - - public: - void* pNext = nullptr; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE_KHR]; - uint32_t deviceNodeMask; - Bool32 deviceLUIDValid; - }; - static_assert( sizeof( PhysicalDeviceIDPropertiesKHR ) == sizeof( VkPhysicalDeviceIDPropertiesKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ExportMemoryWin32HandleInfoKHR - { - ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - { - } - - ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); - } - - ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); - return *this; - } - ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkExportMemoryWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(this); - } - - bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ) - && ( name == rhs.name ); - } - - bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct MemoryWin32HandlePropertiesKHR - { - operator const VkMemoryWin32HandlePropertiesKHR&() const - { - return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(this); - } - - bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; - - public: - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct MemoryFdPropertiesKHR - { - operator const VkMemoryFdPropertiesKHR&() const - { - return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(this); - } - - bool operator==( MemoryFdPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryFdPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryFdPropertiesKHR; - - public: - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct Win32KeyedMutexAcquireReleaseInfoKHR - { - Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeouts( pAcquireTimeouts_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - { - } - - Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); - } - - Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); - return *this; - } - Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ ) - { - acquireCount = acquireCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) - { - pAcquireSyncs = pAcquireSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) - { - pAcquireKeys = pAcquireKeys_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ ) - { - pAcquireTimeouts = pAcquireTimeouts_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ ) - { - releaseCount = releaseCount_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) - { - pReleaseSyncs = pReleaseSyncs_; - return *this; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) - { - pReleaseKeys = pReleaseKeys_; - return *this; - } - - operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const - { - return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this); - } - - bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( acquireCount == rhs.acquireCount ) - && ( pAcquireSyncs == rhs.pAcquireSyncs ) - && ( pAcquireKeys == rhs.pAcquireKeys ) - && ( pAcquireTimeouts == rhs.pAcquireTimeouts ) - && ( releaseCount == rhs.releaseCount ) - && ( pReleaseSyncs == rhs.pReleaseSyncs ) - && ( pReleaseKeys == rhs.pReleaseKeys ); - } - - bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t acquireCount; - const DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeouts; - uint32_t releaseCount; - const DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ExportSemaphoreWin32HandleInfoKHR - { - ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - { - } - - ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); - } - - ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); - return *this; - } - ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkExportSemaphoreWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(this); - } - - bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ) - && ( name == rhs.name ); - } - - bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct D3D12FenceSubmitInfoKHR - { - D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) - : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) - , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) - , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) - , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) - { - } - - D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); - } - - D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); - return *this; - } - D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) - { - waitSemaphoreValuesCount = waitSemaphoreValuesCount_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ ) - { - pWaitSemaphoreValues = pWaitSemaphoreValues_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) - { - signalSemaphoreValuesCount = signalSemaphoreValuesCount_; - return *this; - } - - D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ ) - { - pSignalSemaphoreValues = pSignalSemaphoreValues_; - return *this; - } - - operator const VkD3D12FenceSubmitInfoKHR&() const - { - return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(this); - } - - bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) - && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) - && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) - && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); - } - - bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues; - }; - static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ExportFenceWin32HandleInfoKHR - { - ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - { - } - - ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); - } - - ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); - return *this; - } - ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) - { - pAttributes = pAttributes_; - return *this; - } - - ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) - { - dwAccess = dwAccess_; - return *this; - } - - ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkExportFenceWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(this); - } - - bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pAttributes == rhs.pAttributes ) - && ( dwAccess == rhs.dwAccess ) - && ( name == rhs.name ); - } - - bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct PhysicalDeviceMultiviewFeaturesKHX - { - PhysicalDeviceMultiviewFeaturesKHX( Bool32 multiview_ = 0, Bool32 multiviewGeometryShader_ = 0, Bool32 multiviewTessellationShader_ = 0 ) - : multiview( multiview_ ) - , multiviewGeometryShader( multiviewGeometryShader_ ) - , multiviewTessellationShader( multiviewTessellationShader_ ) - { - } - - PhysicalDeviceMultiviewFeaturesKHX( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) ); - } - - PhysicalDeviceMultiviewFeaturesKHX& operator=( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) ); - return *this; - } - PhysicalDeviceMultiviewFeaturesKHX& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceMultiviewFeaturesKHX& setMultiview( Bool32 multiview_ ) - { - multiview = multiview_; - return *this; - } - - PhysicalDeviceMultiviewFeaturesKHX& setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) - { - multiviewGeometryShader = multiviewGeometryShader_; - return *this; - } - - PhysicalDeviceMultiviewFeaturesKHX& setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) - { - multiviewTessellationShader = multiviewTessellationShader_; - return *this; - } - - operator const VkPhysicalDeviceMultiviewFeaturesKHX&() const - { - return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeaturesKHX*>(this); - } - - bool operator==( PhysicalDeviceMultiviewFeaturesKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( multiview == rhs.multiview ) - && ( multiviewGeometryShader == rhs.multiviewGeometryShader ) - && ( multiviewTessellationShader == rhs.multiviewTessellationShader ); - } - - bool operator!=( PhysicalDeviceMultiviewFeaturesKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMultiviewFeaturesKHX; - - public: - void* pNext = nullptr; - Bool32 multiview; - Bool32 multiviewGeometryShader; - Bool32 multiviewTessellationShader; - }; - static_assert( sizeof( PhysicalDeviceMultiviewFeaturesKHX ) == sizeof( VkPhysicalDeviceMultiviewFeaturesKHX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMultiviewPropertiesKHX - { - operator const VkPhysicalDeviceMultiviewPropertiesKHX&() const - { - return *reinterpret_cast<const VkPhysicalDeviceMultiviewPropertiesKHX*>(this); - } - - bool operator==( PhysicalDeviceMultiviewPropertiesKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) - && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); - } - - bool operator!=( PhysicalDeviceMultiviewPropertiesKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMultiviewPropertiesKHX; - - public: - void* pNext = nullptr; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - }; - static_assert( sizeof( PhysicalDeviceMultiviewPropertiesKHX ) == sizeof( VkPhysicalDeviceMultiviewPropertiesKHX ), "struct and wrapper have different size!" ); - - struct RenderPassMultiviewCreateInfoKHX - { - RenderPassMultiviewCreateInfoKHX( 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 ) - : subpassCount( subpassCount_ ) - , pViewMasks( pViewMasks_ ) - , dependencyCount( dependencyCount_ ) - , pViewOffsets( pViewOffsets_ ) - , correlationMaskCount( correlationMaskCount_ ) - , pCorrelationMasks( pCorrelationMasks_ ) - { - } - - RenderPassMultiviewCreateInfoKHX( VkRenderPassMultiviewCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) ); - } - - RenderPassMultiviewCreateInfoKHX& operator=( VkRenderPassMultiviewCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) ); - return *this; - } - RenderPassMultiviewCreateInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassMultiviewCreateInfoKHX& setSubpassCount( uint32_t subpassCount_ ) - { - subpassCount = subpassCount_; - return *this; - } - - RenderPassMultiviewCreateInfoKHX& setPViewMasks( const uint32_t* pViewMasks_ ) - { - pViewMasks = pViewMasks_; - return *this; - } - - RenderPassMultiviewCreateInfoKHX& setDependencyCount( uint32_t dependencyCount_ ) - { - dependencyCount = dependencyCount_; - return *this; - } - - RenderPassMultiviewCreateInfoKHX& setPViewOffsets( const int32_t* pViewOffsets_ ) - { - pViewOffsets = pViewOffsets_; - return *this; - } - - RenderPassMultiviewCreateInfoKHX& setCorrelationMaskCount( uint32_t correlationMaskCount_ ) - { - correlationMaskCount = correlationMaskCount_; - return *this; - } - - RenderPassMultiviewCreateInfoKHX& setPCorrelationMasks( const uint32_t* pCorrelationMasks_ ) - { - pCorrelationMasks = pCorrelationMasks_; - return *this; - } - - operator const VkRenderPassMultiviewCreateInfoKHX&() const - { - return *reinterpret_cast<const VkRenderPassMultiviewCreateInfoKHX*>(this); - } - - bool operator==( RenderPassMultiviewCreateInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( subpassCount == rhs.subpassCount ) - && ( pViewMasks == rhs.pViewMasks ) - && ( dependencyCount == rhs.dependencyCount ) - && ( pViewOffsets == rhs.pViewOffsets ) - && ( correlationMaskCount == rhs.correlationMaskCount ) - && ( pCorrelationMasks == rhs.pCorrelationMasks ); - } - - bool operator!=( RenderPassMultiviewCreateInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassMultiviewCreateInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; - }; - static_assert( sizeof( RenderPassMultiviewCreateInfoKHX ) == sizeof( VkRenderPassMultiviewCreateInfoKHX ), "struct and wrapper have different size!" ); - - struct BindBufferMemoryInfoKHR - { - BindBufferMemoryInfoKHR( Buffer buffer_ = Buffer(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 ) - : buffer( buffer_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - { - } - - BindBufferMemoryInfoKHR( VkBindBufferMemoryInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHR ) ); - } - - BindBufferMemoryInfoKHR& operator=( VkBindBufferMemoryInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHR ) ); - return *this; - } - BindBufferMemoryInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindBufferMemoryInfoKHR& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - BindBufferMemoryInfoKHR& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - BindBufferMemoryInfoKHR& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - operator const VkBindBufferMemoryInfoKHR&() const - { - return *reinterpret_cast<const VkBindBufferMemoryInfoKHR*>(this); - } - - bool operator==( BindBufferMemoryInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( buffer == rhs.buffer ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ); - } - - bool operator!=( BindBufferMemoryInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindBufferMemoryInfoKHR; - - public: - const void* pNext = nullptr; - Buffer buffer; - DeviceMemory memory; - DeviceSize memoryOffset; - }; - static_assert( sizeof( BindBufferMemoryInfoKHR ) == sizeof( VkBindBufferMemoryInfoKHR ), "struct and wrapper have different size!" ); - - struct BindBufferMemoryDeviceGroupInfoKHX - { - BindBufferMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr ) - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - { - } - - BindBufferMemoryDeviceGroupInfoKHX( VkBindBufferMemoryDeviceGroupInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfoKHX ) ); - } - - BindBufferMemoryDeviceGroupInfoKHX& operator=( VkBindBufferMemoryDeviceGroupInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfoKHX ) ); - return *this; - } - BindBufferMemoryDeviceGroupInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindBufferMemoryDeviceGroupInfoKHX& setDeviceIndexCount( uint32_t deviceIndexCount_ ) - { - deviceIndexCount = deviceIndexCount_; - return *this; - } - - BindBufferMemoryDeviceGroupInfoKHX& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) - { - pDeviceIndices = pDeviceIndices_; - return *this; - } - - operator const VkBindBufferMemoryDeviceGroupInfoKHX&() const - { - return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfoKHX*>(this); - } - - bool operator==( BindBufferMemoryDeviceGroupInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceIndexCount == rhs.deviceIndexCount ) - && ( pDeviceIndices == rhs.pDeviceIndices ); - } - - bool operator!=( BindBufferMemoryDeviceGroupInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - }; - static_assert( sizeof( BindBufferMemoryDeviceGroupInfoKHX ) == sizeof( VkBindBufferMemoryDeviceGroupInfoKHX ), "struct and wrapper have different size!" ); - - struct BindImageMemoryInfoKHR - { - BindImageMemoryInfoKHR( Image image_ = Image(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 ) - : image( image_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - { - } - - BindImageMemoryInfoKHR( VkBindImageMemoryInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHR ) ); - } - - BindImageMemoryInfoKHR& operator=( VkBindImageMemoryInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHR ) ); - return *this; - } - BindImageMemoryInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImageMemoryInfoKHR& setImage( Image image_ ) - { - image = image_; - return *this; - } - - BindImageMemoryInfoKHR& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - BindImageMemoryInfoKHR& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - operator const VkBindImageMemoryInfoKHR&() const - { - return *reinterpret_cast<const VkBindImageMemoryInfoKHR*>(this); - } - - bool operator==( BindImageMemoryInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ); - } - - bool operator!=( BindImageMemoryInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImageMemoryInfoKHR; - - public: - const void* pNext = nullptr; - Image image; - DeviceMemory memory; - DeviceSize memoryOffset; - }; - static_assert( sizeof( BindImageMemoryInfoKHR ) == sizeof( VkBindImageMemoryInfoKHR ), "struct and wrapper have different size!" ); - - struct BindImageMemoryDeviceGroupInfoKHX - { - BindImageMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t SFRRectCount_ = 0, const Rect2D* pSFRRects_ = nullptr ) - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - , SFRRectCount( SFRRectCount_ ) - , pSFRRects( pSFRRects_ ) - { - } - - BindImageMemoryDeviceGroupInfoKHX( VkBindImageMemoryDeviceGroupInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfoKHX ) ); - } - - BindImageMemoryDeviceGroupInfoKHX& operator=( VkBindImageMemoryDeviceGroupInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfoKHX ) ); - return *this; - } - BindImageMemoryDeviceGroupInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImageMemoryDeviceGroupInfoKHX& setDeviceIndexCount( uint32_t deviceIndexCount_ ) - { - deviceIndexCount = deviceIndexCount_; - return *this; - } - - BindImageMemoryDeviceGroupInfoKHX& setPDeviceIndices( const uint32_t* pDeviceIndices_ ) - { - pDeviceIndices = pDeviceIndices_; - return *this; - } - - BindImageMemoryDeviceGroupInfoKHX& setSFRRectCount( uint32_t SFRRectCount_ ) - { - SFRRectCount = SFRRectCount_; - return *this; - } - - BindImageMemoryDeviceGroupInfoKHX& setPSFRRects( const Rect2D* pSFRRects_ ) - { - pSFRRects = pSFRRects_; - return *this; - } - - operator const VkBindImageMemoryDeviceGroupInfoKHX&() const - { - return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfoKHX*>(this); - } - - bool operator==( BindImageMemoryDeviceGroupInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceIndexCount == rhs.deviceIndexCount ) - && ( pDeviceIndices == rhs.pDeviceIndices ) - && ( SFRRectCount == rhs.SFRRectCount ) - && ( pSFRRects == rhs.pSFRRects ); - } - - bool operator!=( BindImageMemoryDeviceGroupInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t SFRRectCount; - const Rect2D* pSFRRects; - }; - static_assert( sizeof( BindImageMemoryDeviceGroupInfoKHX ) == sizeof( VkBindImageMemoryDeviceGroupInfoKHX ), "struct and wrapper have different size!" ); - - struct DeviceGroupRenderPassBeginInfoKHX - { - DeviceGroupRenderPassBeginInfoKHX( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const Rect2D* pDeviceRenderAreas_ = nullptr ) - : deviceMask( deviceMask_ ) - , deviceRenderAreaCount( deviceRenderAreaCount_ ) - , pDeviceRenderAreas( pDeviceRenderAreas_ ) - { - } - - DeviceGroupRenderPassBeginInfoKHX( VkDeviceGroupRenderPassBeginInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) ); - } - - DeviceGroupRenderPassBeginInfoKHX& operator=( VkDeviceGroupRenderPassBeginInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) ); - return *this; - } - DeviceGroupRenderPassBeginInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupRenderPassBeginInfoKHX& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - DeviceGroupRenderPassBeginInfoKHX& setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ ) - { - deviceRenderAreaCount = deviceRenderAreaCount_; - return *this; - } - - DeviceGroupRenderPassBeginInfoKHX& setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ ) - { - pDeviceRenderAreas = pDeviceRenderAreas_; - return *this; - } - - operator const VkDeviceGroupRenderPassBeginInfoKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfoKHX*>(this); - } - - bool operator==( DeviceGroupRenderPassBeginInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceMask == rhs.deviceMask ) - && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) - && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); - } - - bool operator!=( DeviceGroupRenderPassBeginInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const Rect2D* pDeviceRenderAreas; - }; - static_assert( sizeof( DeviceGroupRenderPassBeginInfoKHX ) == sizeof( VkDeviceGroupRenderPassBeginInfoKHX ), "struct and wrapper have different size!" ); - - struct DeviceGroupCommandBufferBeginInfoKHX - { - DeviceGroupCommandBufferBeginInfoKHX( uint32_t deviceMask_ = 0 ) - : deviceMask( deviceMask_ ) - { - } - - DeviceGroupCommandBufferBeginInfoKHX( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) ); - } - - DeviceGroupCommandBufferBeginInfoKHX& operator=( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) ); - return *this; - } - DeviceGroupCommandBufferBeginInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupCommandBufferBeginInfoKHX& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - operator const VkDeviceGroupCommandBufferBeginInfoKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfoKHX*>(this); - } - - bool operator==( DeviceGroupCommandBufferBeginInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceMask == rhs.deviceMask ); - } - - bool operator!=( DeviceGroupCommandBufferBeginInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t deviceMask; - }; - static_assert( sizeof( DeviceGroupCommandBufferBeginInfoKHX ) == sizeof( VkDeviceGroupCommandBufferBeginInfoKHX ), "struct and wrapper have different size!" ); - - struct DeviceGroupSubmitInfoKHX - { - DeviceGroupSubmitInfoKHX( 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 ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ ) - { - } - - DeviceGroupSubmitInfoKHX( VkDeviceGroupSubmitInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) ); - } - - DeviceGroupSubmitInfoKHX& operator=( VkDeviceGroupSubmitInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) ); - return *this; - } - DeviceGroupSubmitInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupSubmitInfoKHX& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - DeviceGroupSubmitInfoKHX& setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ ) - { - pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_; - return *this; - } - - DeviceGroupSubmitInfoKHX& setCommandBufferCount( uint32_t commandBufferCount_ ) - { - commandBufferCount = commandBufferCount_; - return *this; - } - - DeviceGroupSubmitInfoKHX& setPCommandBufferDeviceMasks( const uint32_t* pCommandBufferDeviceMasks_ ) - { - pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_; - return *this; - } - - DeviceGroupSubmitInfoKHX& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - DeviceGroupSubmitInfoKHX& setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ ) - { - pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_; - return *this; - } - - operator const VkDeviceGroupSubmitInfoKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupSubmitInfoKHX*>(this); - } - - bool operator==( DeviceGroupSubmitInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) - && ( commandBufferCount == rhs.commandBufferCount ) - && ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) - && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) - && ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices ); - } - - bool operator!=( DeviceGroupSubmitInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupSubmitInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; - }; - static_assert( sizeof( DeviceGroupSubmitInfoKHX ) == sizeof( VkDeviceGroupSubmitInfoKHX ), "struct and wrapper have different size!" ); - - struct DeviceGroupBindSparseInfoKHX - { - DeviceGroupBindSparseInfoKHX( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 ) - : resourceDeviceIndex( resourceDeviceIndex_ ) - , memoryDeviceIndex( memoryDeviceIndex_ ) - { - } - - DeviceGroupBindSparseInfoKHX( VkDeviceGroupBindSparseInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) ); - } - - DeviceGroupBindSparseInfoKHX& operator=( VkDeviceGroupBindSparseInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) ); - return *this; - } - DeviceGroupBindSparseInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupBindSparseInfoKHX& setResourceDeviceIndex( uint32_t resourceDeviceIndex_ ) - { - resourceDeviceIndex = resourceDeviceIndex_; - return *this; - } - - DeviceGroupBindSparseInfoKHX& setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ ) - { - memoryDeviceIndex = memoryDeviceIndex_; - return *this; - } - - operator const VkDeviceGroupBindSparseInfoKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupBindSparseInfoKHX*>(this); - } - - bool operator==( DeviceGroupBindSparseInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) - && ( memoryDeviceIndex == rhs.memoryDeviceIndex ); - } - - bool operator!=( DeviceGroupBindSparseInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupBindSparseInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; - }; - static_assert( sizeof( DeviceGroupBindSparseInfoKHX ) == sizeof( VkDeviceGroupBindSparseInfoKHX ), "struct and wrapper have different size!" ); - - struct ImageSwapchainCreateInfoKHX - { - ImageSwapchainCreateInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR() ) - : swapchain( swapchain_ ) - { - } - - ImageSwapchainCreateInfoKHX( VkImageSwapchainCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) ); - } - - ImageSwapchainCreateInfoKHX& operator=( VkImageSwapchainCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) ); - return *this; - } - ImageSwapchainCreateInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageSwapchainCreateInfoKHX& setSwapchain( SwapchainKHR swapchain_ ) - { - swapchain = swapchain_; - return *this; - } - - operator const VkImageSwapchainCreateInfoKHX&() const - { - return *reinterpret_cast<const VkImageSwapchainCreateInfoKHX*>(this); - } - - bool operator==( ImageSwapchainCreateInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchain == rhs.swapchain ); - } - - bool operator!=( ImageSwapchainCreateInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageSwapchainCreateInfoKHX; - - public: - const void* pNext = nullptr; - SwapchainKHR swapchain; - }; - static_assert( sizeof( ImageSwapchainCreateInfoKHX ) == sizeof( VkImageSwapchainCreateInfoKHX ), "struct and wrapper have different size!" ); - - struct BindImageMemorySwapchainInfoKHX - { - BindImageMemorySwapchainInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint32_t imageIndex_ = 0 ) - : swapchain( swapchain_ ) - , imageIndex( imageIndex_ ) - { - } - - BindImageMemorySwapchainInfoKHX( VkBindImageMemorySwapchainInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) ); - } - - BindImageMemorySwapchainInfoKHX& operator=( VkBindImageMemorySwapchainInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) ); - return *this; - } - BindImageMemorySwapchainInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImageMemorySwapchainInfoKHX& setSwapchain( SwapchainKHR swapchain_ ) - { - swapchain = swapchain_; - return *this; - } - - BindImageMemorySwapchainInfoKHX& setImageIndex( uint32_t imageIndex_ ) - { - imageIndex = imageIndex_; - return *this; - } - - operator const VkBindImageMemorySwapchainInfoKHX&() const - { - return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHX*>(this); - } - - bool operator==( BindImageMemorySwapchainInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchain == rhs.swapchain ) - && ( imageIndex == rhs.imageIndex ); - } - - bool operator!=( BindImageMemorySwapchainInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHX; - - public: - const void* pNext = nullptr; - SwapchainKHR swapchain; - uint32_t imageIndex; - }; - static_assert( sizeof( BindImageMemorySwapchainInfoKHX ) == sizeof( VkBindImageMemorySwapchainInfoKHX ), "struct and wrapper have different size!" ); - - struct AcquireNextImageInfoKHX - { - AcquireNextImageInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint64_t timeout_ = 0, Semaphore semaphore_ = Semaphore(), Fence fence_ = Fence(), uint32_t deviceMask_ = 0 ) - : swapchain( swapchain_ ) - , timeout( timeout_ ) - , semaphore( semaphore_ ) - , fence( fence_ ) - , deviceMask( deviceMask_ ) - { - } - - AcquireNextImageInfoKHX( VkAcquireNextImageInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) ); - } - - AcquireNextImageInfoKHX& operator=( VkAcquireNextImageInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) ); - return *this; - } - AcquireNextImageInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - AcquireNextImageInfoKHX& setSwapchain( SwapchainKHR swapchain_ ) - { - swapchain = swapchain_; - return *this; - } - - AcquireNextImageInfoKHX& setTimeout( uint64_t timeout_ ) - { - timeout = timeout_; - return *this; - } - - AcquireNextImageInfoKHX& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - AcquireNextImageInfoKHX& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - AcquireNextImageInfoKHX& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - operator const VkAcquireNextImageInfoKHX&() const - { - return *reinterpret_cast<const VkAcquireNextImageInfoKHX*>(this); - } - - bool operator==( AcquireNextImageInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchain == rhs.swapchain ) - && ( timeout == rhs.timeout ) - && ( semaphore == rhs.semaphore ) - && ( fence == rhs.fence ) - && ( deviceMask == rhs.deviceMask ); - } - - bool operator!=( AcquireNextImageInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eAcquireNextImageInfoKHX; - - public: - const void* pNext = nullptr; - SwapchainKHR swapchain; - uint64_t timeout; - Semaphore semaphore; - Fence fence; - uint32_t deviceMask; - }; - static_assert( sizeof( AcquireNextImageInfoKHX ) == sizeof( VkAcquireNextImageInfoKHX ), "struct and wrapper have different size!" ); - - struct HdrMetadataEXT - { - 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 ) - : displayPrimaryRed( displayPrimaryRed_ ) - , displayPrimaryGreen( displayPrimaryGreen_ ) - , displayPrimaryBlue( displayPrimaryBlue_ ) - , whitePoint( whitePoint_ ) - , maxLuminance( maxLuminance_ ) - , minLuminance( minLuminance_ ) - , maxContentLightLevel( maxContentLightLevel_ ) - , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ ) - { - } - - HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); - } - - HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); - return *this; - } - HdrMetadataEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - HdrMetadataEXT& setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ ) - { - displayPrimaryRed = displayPrimaryRed_; - return *this; - } - - HdrMetadataEXT& setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ ) - { - displayPrimaryGreen = displayPrimaryGreen_; - return *this; - } - - HdrMetadataEXT& setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ ) - { - displayPrimaryBlue = displayPrimaryBlue_; - return *this; - } - - HdrMetadataEXT& setWhitePoint( XYColorEXT whitePoint_ ) - { - whitePoint = whitePoint_; - return *this; - } - - HdrMetadataEXT& setMaxLuminance( float maxLuminance_ ) - { - maxLuminance = maxLuminance_; - return *this; - } - - HdrMetadataEXT& setMinLuminance( float minLuminance_ ) - { - minLuminance = minLuminance_; - return *this; - } - - HdrMetadataEXT& setMaxContentLightLevel( float maxContentLightLevel_ ) - { - maxContentLightLevel = maxContentLightLevel_; - return *this; - } - - HdrMetadataEXT& setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) - { - maxFrameAverageLightLevel = maxFrameAverageLightLevel_; - return *this; - } - - operator const VkHdrMetadataEXT&() const - { - return *reinterpret_cast<const VkHdrMetadataEXT*>(this); - } - - bool operator==( HdrMetadataEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( displayPrimaryRed == rhs.displayPrimaryRed ) - && ( displayPrimaryGreen == rhs.displayPrimaryGreen ) - && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) - && ( whitePoint == rhs.whitePoint ) - && ( maxLuminance == rhs.maxLuminance ) - && ( minLuminance == rhs.minLuminance ) - && ( maxContentLightLevel == rhs.maxContentLightLevel ) - && ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel ); - } - - bool operator!=( HdrMetadataEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eHdrMetadataEXT; - - public: - const void* pNext = nullptr; - XYColorEXT displayPrimaryRed; - XYColorEXT displayPrimaryGreen; - XYColorEXT displayPrimaryBlue; - XYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; - }; - static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); - - struct PresentTimesInfoGOOGLE - { - PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, const PresentTimeGOOGLE* pTimes_ = nullptr ) - : swapchainCount( swapchainCount_ ) - , pTimes( pTimes_ ) - { - } - - PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); - } - - PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); - return *this; - } - PresentTimesInfoGOOGLE& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PresentTimesInfoGOOGLE& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - PresentTimesInfoGOOGLE& setPTimes( const PresentTimeGOOGLE* pTimes_ ) - { - pTimes = pTimes_; - return *this; - } - - operator const VkPresentTimesInfoGOOGLE&() const - { - return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(this); - } - - bool operator==( PresentTimesInfoGOOGLE const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pTimes == rhs.pTimes ); - } - - bool operator!=( PresentTimesInfoGOOGLE const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePresentTimesInfoGOOGLE; - - public: - const void* pNext = nullptr; - uint32_t swapchainCount; - const PresentTimeGOOGLE* pTimes; - }; - static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_IOS_MVK - struct IOSSurfaceCreateInfoMVK - { - IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) - : flags( flags_ ) - , pView( pView_ ) - { - } - - IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); - } - - IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); - return *this; - } - IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - IOSSurfaceCreateInfoMVK& setFlags( IOSSurfaceCreateFlagsMVK flags_ ) - { - flags = flags_; - return *this; - } - - IOSSurfaceCreateInfoMVK& setPView( const void* pView_ ) - { - pView = pView_; - return *this; - } - - operator const VkIOSSurfaceCreateInfoMVK&() const - { - return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(this); - } - - bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pView == rhs.pView ); - } - - bool operator!=( IOSSurfaceCreateInfoMVK const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; - - public: - const void* pNext = nullptr; - IOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - struct MacOSSurfaceCreateInfoMVK - { - MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) - : flags( flags_ ) - , pView( pView_ ) - { - } - - MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); - } - - MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) - { - memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); - return *this; - } - MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MacOSSurfaceCreateInfoMVK& setFlags( MacOSSurfaceCreateFlagsMVK flags_ ) - { - flags = flags_; - return *this; - } - - MacOSSurfaceCreateInfoMVK& setPView( const void* pView_ ) - { - pView = pView_; - return *this; - } - - operator const VkMacOSSurfaceCreateInfoMVK&() const - { - return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(this); - } - - bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pView == rhs.pView ); - } - - bool operator!=( MacOSSurfaceCreateInfoMVK const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; - - public: - const void* pNext = nullptr; - MacOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - struct PipelineViewportWScalingStateCreateInfoNV - { - PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const ViewportWScalingNV* pViewportWScalings_ = nullptr ) - : viewportWScalingEnable( viewportWScalingEnable_ ) - , viewportCount( viewportCount_ ) - , pViewportWScalings( pViewportWScalings_ ) - { - } - - PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); - } - - PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); - return *this; - } - PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineViewportWScalingStateCreateInfoNV& setViewportWScalingEnable( Bool32 viewportWScalingEnable_ ) - { - viewportWScalingEnable = viewportWScalingEnable_; - return *this; - } - - PipelineViewportWScalingStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ ) - { - viewportCount = viewportCount_; - return *this; - } - - PipelineViewportWScalingStateCreateInfoNV& setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ ) - { - pViewportWScalings = pViewportWScalings_; - return *this; - } - - operator const VkPipelineViewportWScalingStateCreateInfoNV&() const - { - return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(this); - } - - bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( viewportWScalingEnable == rhs.viewportWScalingEnable ) - && ( viewportCount == rhs.viewportCount ) - && ( pViewportWScalings == rhs.pViewportWScalings ); - } - - bool operator!=( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; - - public: - const void* pNext = nullptr; - Bool32 viewportWScalingEnable; - uint32_t viewportCount; - const ViewportWScalingNV* pViewportWScalings; - }; - static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceDiscardRectanglePropertiesEXT - { - PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 ) - : maxDiscardRectangles( maxDiscardRectangles_ ) - { - } - - PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); - } - - PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); - return *this; - } - PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceDiscardRectanglePropertiesEXT& setMaxDiscardRectangles( uint32_t maxDiscardRectangles_ ) - { - maxDiscardRectangles = maxDiscardRectangles_; - return *this; - } - - operator const VkPhysicalDeviceDiscardRectanglePropertiesEXT&() const - { - return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this); - } - - bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); - } - - bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t maxDiscardRectangles; - }; - static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX - { - operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const - { - return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this); - } - - bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); - } - - bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - - public: - void* pNext = nullptr; - Bool32 perViewPositionAllComponents; - }; - static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSurfaceInfo2KHR - { - PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() ) - : surface( surface_ ) - { - } - - PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); - } - - PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); - return *this; - } - PhysicalDeviceSurfaceInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceSurfaceInfo2KHR& setSurface( SurfaceKHR surface_ ) - { - surface = surface_; - return *this; - } - - operator const VkPhysicalDeviceSurfaceInfo2KHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(this); - } - - bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surface == rhs.surface ); - } - - bool operator!=( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; - - public: - const void* pNext = nullptr; - SurfaceKHR surface; - }; - static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); - - struct PhysicalDevice16BitStorageFeaturesKHR - { - PhysicalDevice16BitStorageFeaturesKHR( Bool32 storageBuffer16BitAccess_ = 0, Bool32 uniformAndStorageBuffer16BitAccess_ = 0, Bool32 storagePushConstant16_ = 0, Bool32 storageInputOutput16_ = 0 ) - : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) - , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) - , storagePushConstant16( storagePushConstant16_ ) - , storageInputOutput16( storageInputOutput16_ ) - { - } - - PhysicalDevice16BitStorageFeaturesKHR( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) ); - } - - PhysicalDevice16BitStorageFeaturesKHR& operator=( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) ); - return *this; - } - PhysicalDevice16BitStorageFeaturesKHR& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDevice16BitStorageFeaturesKHR& setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) - { - storageBuffer16BitAccess = storageBuffer16BitAccess_; - return *this; - } - - PhysicalDevice16BitStorageFeaturesKHR& setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) - { - uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; - return *this; - } - - PhysicalDevice16BitStorageFeaturesKHR& setStoragePushConstant16( Bool32 storagePushConstant16_ ) - { - storagePushConstant16 = storagePushConstant16_; - return *this; - } - - PhysicalDevice16BitStorageFeaturesKHR& setStorageInputOutput16( Bool32 storageInputOutput16_ ) - { - storageInputOutput16 = storageInputOutput16_; - return *this; - } - - operator const VkPhysicalDevice16BitStorageFeaturesKHR&() const - { - return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeaturesKHR*>(this); - } - - bool operator==( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) - && ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) - && ( storagePushConstant16 == rhs.storagePushConstant16 ) - && ( storageInputOutput16 == rhs.storageInputOutput16 ); - } - - bool operator!=( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDevice16BitStorageFeaturesKHR; - - public: - void* pNext = nullptr; - Bool32 storageBuffer16BitAccess; - Bool32 uniformAndStorageBuffer16BitAccess; - Bool32 storagePushConstant16; - Bool32 storageInputOutput16; - }; - static_assert( sizeof( PhysicalDevice16BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice16BitStorageFeaturesKHR ), "struct and wrapper have different size!" ); - - struct BufferMemoryRequirementsInfo2KHR - { - BufferMemoryRequirementsInfo2KHR( Buffer buffer_ = Buffer() ) - : buffer( buffer_ ) - { - } - - BufferMemoryRequirementsInfo2KHR( VkBufferMemoryRequirementsInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) ); - } - - BufferMemoryRequirementsInfo2KHR& operator=( VkBufferMemoryRequirementsInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) ); - return *this; - } - BufferMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferMemoryRequirementsInfo2KHR& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkBufferMemoryRequirementsInfo2KHR&() const - { - return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>(this); - } - - bool operator==( BufferMemoryRequirementsInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( BufferMemoryRequirementsInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferMemoryRequirementsInfo2KHR; - - public: - const void* pNext = nullptr; - Buffer buffer; - }; - static_assert( sizeof( BufferMemoryRequirementsInfo2KHR ) == sizeof( VkBufferMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); - - struct ImageMemoryRequirementsInfo2KHR - { - ImageMemoryRequirementsInfo2KHR( Image image_ = Image() ) - : image( image_ ) - { - } - - ImageMemoryRequirementsInfo2KHR( VkImageMemoryRequirementsInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) ); - } - - ImageMemoryRequirementsInfo2KHR& operator=( VkImageMemoryRequirementsInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) ); - return *this; - } - ImageMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageMemoryRequirementsInfo2KHR& setImage( Image image_ ) - { - image = image_; - return *this; - } - - operator const VkImageMemoryRequirementsInfo2KHR&() const - { - return *reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>(this); - } - - bool operator==( ImageMemoryRequirementsInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ); - } - - bool operator!=( ImageMemoryRequirementsInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageMemoryRequirementsInfo2KHR; - - public: - const void* pNext = nullptr; - Image image; - }; - static_assert( sizeof( ImageMemoryRequirementsInfo2KHR ) == sizeof( VkImageMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); - - struct ImageSparseMemoryRequirementsInfo2KHR - { - ImageSparseMemoryRequirementsInfo2KHR( Image image_ = Image() ) - : image( image_ ) - { - } - - ImageSparseMemoryRequirementsInfo2KHR( VkImageSparseMemoryRequirementsInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) ); - } - - ImageSparseMemoryRequirementsInfo2KHR& operator=( VkImageSparseMemoryRequirementsInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) ); - return *this; - } - ImageSparseMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageSparseMemoryRequirementsInfo2KHR& setImage( Image image_ ) - { - image = image_; - return *this; - } - - operator const VkImageSparseMemoryRequirementsInfo2KHR&() const - { - return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>(this); - } - - bool operator==( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ); - } - - bool operator!=( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2KHR; - - public: - const void* pNext = nullptr; - Image image; - }; - static_assert( sizeof( ImageSparseMemoryRequirementsInfo2KHR ) == sizeof( VkImageSparseMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); - - struct MemoryRequirements2KHR - { - operator const VkMemoryRequirements2KHR&() const - { - return *reinterpret_cast<const VkMemoryRequirements2KHR*>(this); - } - - bool operator==( MemoryRequirements2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryRequirements == rhs.memoryRequirements ); - } - - bool operator!=( MemoryRequirements2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryRequirements2KHR; - - public: - void* pNext = nullptr; - MemoryRequirements memoryRequirements; - }; - static_assert( sizeof( MemoryRequirements2KHR ) == sizeof( VkMemoryRequirements2KHR ), "struct and wrapper have different size!" ); - - struct MemoryDedicatedRequirementsKHR - { - operator const VkMemoryDedicatedRequirementsKHR&() const - { - return *reinterpret_cast<const VkMemoryDedicatedRequirementsKHR*>(this); - } - - bool operator==( MemoryDedicatedRequirementsKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) - && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); - } - - bool operator!=( MemoryDedicatedRequirementsKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryDedicatedRequirementsKHR; - - public: - void* pNext = nullptr; - Bool32 prefersDedicatedAllocation; - Bool32 requiresDedicatedAllocation; - }; - static_assert( sizeof( MemoryDedicatedRequirementsKHR ) == sizeof( VkMemoryDedicatedRequirementsKHR ), "struct and wrapper have different size!" ); - - struct MemoryDedicatedAllocateInfoKHR - { - MemoryDedicatedAllocateInfoKHR( Image image_ = Image(), Buffer buffer_ = Buffer() ) - : image( image_ ) - , buffer( buffer_ ) - { - } - - MemoryDedicatedAllocateInfoKHR( VkMemoryDedicatedAllocateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) ); - } - - MemoryDedicatedAllocateInfoKHR& operator=( VkMemoryDedicatedAllocateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) ); - return *this; - } - MemoryDedicatedAllocateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryDedicatedAllocateInfoKHR& setImage( Image image_ ) - { - image = image_; - return *this; - } - - MemoryDedicatedAllocateInfoKHR& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkMemoryDedicatedAllocateInfoKHR&() const - { - return *reinterpret_cast<const VkMemoryDedicatedAllocateInfoKHR*>(this); - } - - bool operator==( MemoryDedicatedAllocateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( image == rhs.image ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( MemoryDedicatedAllocateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryDedicatedAllocateInfoKHR; - - public: - const void* pNext = nullptr; - Image image; - Buffer buffer; - }; - static_assert( sizeof( MemoryDedicatedAllocateInfoKHR ) == sizeof( VkMemoryDedicatedAllocateInfoKHR ), "struct and wrapper have different size!" ); - - struct SamplerYcbcrConversionInfoKHR - { - SamplerYcbcrConversionInfoKHR( SamplerYcbcrConversionKHR conversion_ = SamplerYcbcrConversionKHR() ) - : conversion( conversion_ ) - { - } - - SamplerYcbcrConversionInfoKHR( VkSamplerYcbcrConversionInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfoKHR ) ); - } - - SamplerYcbcrConversionInfoKHR& operator=( VkSamplerYcbcrConversionInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfoKHR ) ); - return *this; - } - SamplerYcbcrConversionInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerYcbcrConversionInfoKHR& setConversion( SamplerYcbcrConversionKHR conversion_ ) - { - conversion = conversion_; - return *this; - } - - operator const VkSamplerYcbcrConversionInfoKHR&() const - { - return *reinterpret_cast<const VkSamplerYcbcrConversionInfoKHR*>(this); - } - - bool operator==( SamplerYcbcrConversionInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( conversion == rhs.conversion ); - } - - bool operator!=( SamplerYcbcrConversionInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerYcbcrConversionInfoKHR; - - public: - const void* pNext = nullptr; - SamplerYcbcrConversionKHR conversion; - }; - static_assert( sizeof( SamplerYcbcrConversionInfoKHR ) == sizeof( VkSamplerYcbcrConversionInfoKHR ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR - { - PhysicalDeviceSamplerYcbcrConversionFeaturesKHR( Bool32 samplerYcbcrConversion_ = 0 ) - : samplerYcbcrConversion( samplerYcbcrConversion_ ) - { - } - - PhysicalDeviceSamplerYcbcrConversionFeaturesKHR( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) ); - } - - PhysicalDeviceSamplerYcbcrConversionFeaturesKHR& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) ); - return *this; - } - PhysicalDeviceSamplerYcbcrConversionFeaturesKHR& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceSamplerYcbcrConversionFeaturesKHR& setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) - { - samplerYcbcrConversion = samplerYcbcrConversion_; - return *this; - } - - operator const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR*>(this); - } - - bool operator==( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); - } - - bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR; - - public: - void* pNext = nullptr; - Bool32 samplerYcbcrConversion; - }; - static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ), "struct and wrapper have different size!" ); - - struct SamplerYcbcrConversionImageFormatPropertiesKHR - { - operator const VkSamplerYcbcrConversionImageFormatPropertiesKHR&() const - { - return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatPropertiesKHR*>(this); - } - - bool operator==( SamplerYcbcrConversionImageFormatPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); - } - - bool operator!=( SamplerYcbcrConversionImageFormatPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR; - - public: - void* pNext = nullptr; - uint32_t combinedImageSamplerDescriptorCount; - }; - static_assert( sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) == sizeof( VkSamplerYcbcrConversionImageFormatPropertiesKHR ), "struct and wrapper have different size!" ); - - struct TextureLODGatherFormatPropertiesAMD - { - operator const VkTextureLODGatherFormatPropertiesAMD&() const - { - return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this); - } - - bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); - } - - bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; - - public: - void* pNext = nullptr; - Bool32 supportsTextureGatherLODBiasAMD; - }; - static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); - - struct PipelineCoverageToColorStateCreateInfoNV - { - PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 ) - : flags( flags_ ) - , coverageToColorEnable( coverageToColorEnable_ ) - , coverageToColorLocation( coverageToColorLocation_ ) - { - } - - PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); - } - - PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); - return *this; - } - PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) - { - flags = flags_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) - { - coverageToColorEnable = coverageToColorEnable_; - return *this; - } - - PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) - { - coverageToColorLocation = coverageToColorLocation_; - return *this; - } - - operator const VkPipelineCoverageToColorStateCreateInfoNV&() const - { - return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(this); - } - - bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( coverageToColorEnable == rhs.coverageToColorEnable ) - && ( coverageToColorLocation == rhs.coverageToColorLocation ); - } - - bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; - - public: - const void* pNext = nullptr; - PipelineCoverageToColorStateCreateFlagsNV flags; - Bool32 coverageToColorEnable; - uint32_t coverageToColorLocation; - }; - static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT - { - operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const - { - return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this); - } - - bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) - && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); - } - - bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; - - public: - void* pNext = nullptr; - Bool32 filterMinmaxSingleComponentFormats; - Bool32 filterMinmaxImageComponentMapping; - }; - static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); - - struct MultisamplePropertiesEXT - { - operator const VkMultisamplePropertiesEXT&() const - { - return *reinterpret_cast<const VkMultisamplePropertiesEXT*>(this); - } - - bool operator==( MultisamplePropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); - } - - bool operator!=( MultisamplePropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMultisamplePropertiesEXT; - - public: - void* pNext = nullptr; - Extent2D maxSampleLocationGridSize; - }; - static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT - { - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 ) - : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) - { - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); - return *this; - } - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) - { - advancedBlendCoherentOperations = advancedBlendCoherentOperations_; - return *this; - } - - operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const - { - return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this); - } - - bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); - } - - bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; - - public: - void* pNext = nullptr; - Bool32 advancedBlendCoherentOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT - { - operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const - { - return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this); - } - - bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) - && ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) - && ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) - && ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) - && ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) - && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); - } - - bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t advancedBlendMaxColorAttachments; - Bool32 advancedBlendIndependentBlend; - Bool32 advancedBlendNonPremultipliedSrcColor; - Bool32 advancedBlendNonPremultipliedDstColor; - Bool32 advancedBlendCorrelatedOverlap; - Bool32 advancedBlendAllOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); - - struct ImageFormatListCreateInfoKHR - { - ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, const Format* pViewFormats_ = nullptr ) - : viewFormatCount( viewFormatCount_ ) - , pViewFormats( pViewFormats_ ) - { - } - - ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) ); - } - - ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) ); - return *this; - } - ImageFormatListCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageFormatListCreateInfoKHR& setViewFormatCount( uint32_t viewFormatCount_ ) - { - viewFormatCount = viewFormatCount_; - return *this; - } - - ImageFormatListCreateInfoKHR& setPViewFormats( const Format* pViewFormats_ ) - { - pViewFormats = pViewFormats_; - return *this; - } - - operator const VkImageFormatListCreateInfoKHR&() const - { - return *reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(this); - } - - bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( viewFormatCount == rhs.viewFormatCount ) - && ( pViewFormats == rhs.pViewFormats ); - } - - bool operator!=( ImageFormatListCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageFormatListCreateInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t viewFormatCount; - const Format* pViewFormats; - }; - static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct ValidationCacheCreateInfoEXT - { - ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - { - } - - ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) ); - } - - ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) ); - return *this; - } - ValidationCacheCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ValidationCacheCreateInfoEXT& setFlags( ValidationCacheCreateFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - ValidationCacheCreateInfoEXT& setInitialDataSize( size_t initialDataSize_ ) - { - initialDataSize = initialDataSize_; - return *this; - } - - ValidationCacheCreateInfoEXT& setPInitialData( const void* pInitialData_ ) - { - pInitialData = pInitialData_; - return *this; - } - - operator const VkValidationCacheCreateInfoEXT&() const - { - return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(this); - } - - bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( initialDataSize == rhs.initialDataSize ) - && ( pInitialData == rhs.pInitialData ); - } - - bool operator!=( ValidationCacheCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eValidationCacheCreateInfoEXT; - - public: - const void* pNext = nullptr; - ValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); - - struct ShaderModuleValidationCacheCreateInfoEXT - { - ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() ) - : validationCache( validationCache_ ) - { - } - - ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) ); - } - - ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) ); - return *this; - } - ShaderModuleValidationCacheCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ShaderModuleValidationCacheCreateInfoEXT& setValidationCache( ValidationCacheEXT validationCache_ ) - { - validationCache = validationCache_; - return *this; - } - - operator const VkShaderModuleValidationCacheCreateInfoEXT&() const - { - return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(this); - } - - bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( validationCache == rhs.validationCache ); - } - - bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; - - public: - const void* pNext = nullptr; - ValidationCacheEXT validationCache; - }; - static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); - - struct MemoryHostPointerPropertiesEXT - { - MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 ) - : memoryTypeBits( memoryTypeBits_ ) - { - } - - MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) ); - } - - MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) ); - return *this; - } - MemoryHostPointerPropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryHostPointerPropertiesEXT& setMemoryTypeBits( uint32_t memoryTypeBits_ ) - { - memoryTypeBits = memoryTypeBits_; - return *this; - } - - operator const VkMemoryHostPointerPropertiesEXT&() const - { - return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(this); - } - - bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryHostPointerPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; - - public: - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceExternalMemoryHostPropertiesEXT - { - PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 ) - : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) - { - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) ); - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) ); - return *this; - } - PhysicalDeviceExternalMemoryHostPropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT& setMinImportedHostPointerAlignment( DeviceSize minImportedHostPointerAlignment_ ) - { - minImportedHostPointerAlignment = minImportedHostPointerAlignment_; - return *this; - } - - operator const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&() const - { - return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this); - } - - bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); - } - - bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; - - public: - void* pNext = nullptr; - DeviceSize minImportedHostPointerAlignment; - }; - static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceConservativeRasterizationPropertiesEXT - { - 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 ) - : primitiveOverestimationSize( primitiveOverestimationSize_ ) - , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ ) - , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ ) - , primitiveUnderestimation( primitiveUnderestimation_ ) - , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ ) - , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ ) - , degenerateLinesRasterized( degenerateLinesRasterized_ ) - , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ ) - , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ ) - { - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) ); - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) ); - return *this; - } - PhysicalDeviceConservativeRasterizationPropertiesEXT& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveOverestimationSize( float primitiveOverestimationSize_ ) - { - primitiveOverestimationSize = primitiveOverestimationSize_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setMaxExtraPrimitiveOverestimationSize( float maxExtraPrimitiveOverestimationSize_ ) - { - maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setExtraPrimitiveOverestimationSizeGranularity( float extraPrimitiveOverestimationSizeGranularity_ ) - { - extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveUnderestimation( Bool32 primitiveUnderestimation_ ) - { - primitiveUnderestimation = primitiveUnderestimation_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativePointAndLineRasterization( Bool32 conservativePointAndLineRasterization_ ) - { - conservativePointAndLineRasterization = conservativePointAndLineRasterization_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateTrianglesRasterized( Bool32 degenerateTrianglesRasterized_ ) - { - degenerateTrianglesRasterized = degenerateTrianglesRasterized_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateLinesRasterized( Bool32 degenerateLinesRasterized_ ) - { - degenerateLinesRasterized = degenerateLinesRasterized_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setFullyCoveredFragmentShaderInputVariable( Bool32 fullyCoveredFragmentShaderInputVariable_ ) - { - fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable_; - return *this; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativeRasterizationPostDepthCoverage( Bool32 conservativeRasterizationPostDepthCoverage_ ) - { - conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage_; - return *this; - } - - operator const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&() const - { - return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this); - } - - bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) - && ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) - && ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) - && ( primitiveUnderestimation == rhs.primitiveUnderestimation ) - && ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) - && ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) - && ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) - && ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) - && ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage ); - } - - bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; - - public: - void* pNext = nullptr; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - Bool32 primitiveUnderestimation; - Bool32 conservativePointAndLineRasterization; - Bool32 degenerateTrianglesRasterized; - Bool32 degenerateLinesRasterized; - Bool32 fullyCoveredFragmentShaderInputVariable; - Bool32 conservativeRasterizationPostDepthCoverage; - }; - static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); - - enum class SubpassContents - { - eInline = VK_SUBPASS_CONTENTS_INLINE, - eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - }; - - struct PresentInfoKHR - { - 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 ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , swapchainCount( swapchainCount_ ) - , pSwapchains( pSwapchains_ ) - , pImageIndices( pImageIndices_ ) - , pResults( pResults_ ) - { - } - - PresentInfoKHR( VkPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); - } - - PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); - return *this; - } - PresentInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ ) - { - pSwapchains = pSwapchains_; - return *this; - } - - PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ ) - { - pImageIndices = pImageIndices_; - return *this; - } - - PresentInfoKHR& setPResults( Result* pResults_ ) - { - pResults = pResults_; - return *this; - } - - operator const VkPresentInfoKHR&() const - { - return *reinterpret_cast<const VkPresentInfoKHR*>(this); - } - - bool operator==( PresentInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pSwapchains == rhs.pSwapchains ) - && ( pImageIndices == rhs.pImageIndices ) - && ( pResults == rhs.pResults ); - } - - bool operator!=( PresentInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePresentInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - uint32_t swapchainCount; - const SwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - Result* pResults; - }; - static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); - - enum class DynamicState - { - eViewport = VK_DYNAMIC_STATE_VIEWPORT, - eScissor = VK_DYNAMIC_STATE_SCISSOR, - eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, - eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, - eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, - eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, - eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, - eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, - eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, - eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, - eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, - eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT - }; - - struct PipelineDynamicStateCreateInfo - { - PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr ) - : flags( flags_ ) - , dynamicStateCount( dynamicStateCount_ ) - , pDynamicStates( pDynamicStates_ ) - { - } - - PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); - } - - PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); - return *this; - } - PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ ) - { - dynamicStateCount = dynamicStateCount_; - return *this; - } - - PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ ) - { - pDynamicStates = pDynamicStates_; - return *this; - } - - operator const VkPipelineDynamicStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this); - } - - bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( dynamicStateCount == rhs.dynamicStateCount ) - && ( pDynamicStates == rhs.pDynamicStates ); - } - - bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const DynamicState* pDynamicStates; - }; - static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); - - enum class DescriptorUpdateTemplateTypeKHR - { - eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, - ePushDescriptors = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - }; - - struct DescriptorUpdateTemplateCreateInfoKHR - { - DescriptorUpdateTemplateCreateInfoKHR( DescriptorUpdateTemplateCreateFlagsKHR flags_ = DescriptorUpdateTemplateCreateFlagsKHR(), uint32_t descriptorUpdateEntryCount_ = 0, const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ = nullptr, DescriptorUpdateTemplateTypeKHR templateType_ = DescriptorUpdateTemplateTypeKHR::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_ = PipelineLayout(), uint32_t set_ = 0 ) - : flags( flags_ ) - , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) - , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) - , templateType( templateType_ ) - , descriptorSetLayout( descriptorSetLayout_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , pipelineLayout( pipelineLayout_ ) - , set( set_ ) - { - } - - DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); - } - - DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); - return *this; - } - DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setFlags( DescriptorUpdateTemplateCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) - { - descriptorUpdateEntryCount = descriptorUpdateEntryCount_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ ) - { - pDescriptorUpdateEntries = pDescriptorUpdateEntries_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setTemplateType( DescriptorUpdateTemplateTypeKHR templateType_ ) - { - templateType = templateType_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) - { - descriptorSetLayout = descriptorSetLayout_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setPipelineLayout( PipelineLayout pipelineLayout_ ) - { - pipelineLayout = pipelineLayout_; - return *this; - } - - DescriptorUpdateTemplateCreateInfoKHR& setSet( uint32_t set_ ) - { - set = set_; - return *this; - } - - operator const VkDescriptorUpdateTemplateCreateInfoKHR&() const - { - return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>(this); - } - - bool operator==( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) - && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) - && ( templateType == rhs.templateType ) - && ( descriptorSetLayout == rhs.descriptorSetLayout ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( set == rhs.set ); - } - - bool operator!=( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfoKHR; - - public: - void* pNext = nullptr; - DescriptorUpdateTemplateCreateFlagsKHR flags; - uint32_t descriptorUpdateEntryCount; - const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries; - DescriptorUpdateTemplateTypeKHR templateType; - DescriptorSetLayout descriptorSetLayout; - PipelineBindPoint pipelineBindPoint; - PipelineLayout pipelineLayout; - uint32_t set; - }; - static_assert( sizeof( DescriptorUpdateTemplateCreateInfoKHR ) == sizeof( VkDescriptorUpdateTemplateCreateInfoKHR ), "struct and wrapper have different size!" ); - - enum class ObjectType - { - eUnknown = VK_OBJECT_TYPE_UNKNOWN, - eInstance = VK_OBJECT_TYPE_INSTANCE, - ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, - eDevice = VK_OBJECT_TYPE_DEVICE, - eQueue = VK_OBJECT_TYPE_QUEUE, - eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, - eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, - eFence = VK_OBJECT_TYPE_FENCE, - eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, - eBuffer = VK_OBJECT_TYPE_BUFFER, - eImage = VK_OBJECT_TYPE_IMAGE, - eEvent = VK_OBJECT_TYPE_EVENT, - eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, - eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, - eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, - eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, - ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, - ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, - eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, - ePipeline = VK_OBJECT_TYPE_PIPELINE, - eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, - eSampler = VK_OBJECT_TYPE_SAMPLER, - eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, - eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, - eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, - eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, - eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, - eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, - eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, - eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, - eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, - eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, - eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX, - eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX, - eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, - eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT - }; - - enum class QueueFlagBits - { - eGraphics = VK_QUEUE_GRAPHICS_BIT, - eCompute = VK_QUEUE_COMPUTE_BIT, - eTransfer = VK_QUEUE_TRANSFER_BIT, - eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT - }; - - using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>; - - VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 ) - { - return QueueFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits ) - { - return ~( QueueFlags( bits ) ); - } - - template <> struct FlagTraits<QueueFlagBits> - { - enum - { - allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding) - }; - }; - - struct QueueFamilyProperties - { - operator const VkQueueFamilyProperties&() const - { - return *reinterpret_cast<const VkQueueFamilyProperties*>(this); - } - - bool operator==( QueueFamilyProperties const& rhs ) const - { - return ( queueFlags == rhs.queueFlags ) - && ( queueCount == rhs.queueCount ) - && ( timestampValidBits == rhs.timestampValidBits ) - && ( minImageTransferGranularity == rhs.minImageTransferGranularity ); - } - - bool operator!=( QueueFamilyProperties const& rhs ) const - { - return !operator==( rhs ); - } - - QueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - Extent3D minImageTransferGranularity; - }; - static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); - - struct QueueFamilyProperties2KHR - { - operator const VkQueueFamilyProperties2KHR&() const - { - return *reinterpret_cast<const VkQueueFamilyProperties2KHR*>(this); - } - - bool operator==( QueueFamilyProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( queueFamilyProperties == rhs.queueFamilyProperties ); - } - - bool operator!=( QueueFamilyProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eQueueFamilyProperties2KHR; - - public: - void* pNext = nullptr; - QueueFamilyProperties queueFamilyProperties; - }; - static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" ); - - enum class MemoryPropertyFlagBits - { - eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, - eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT - }; - - using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>; - - VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 ) - { - return MemoryPropertyFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits ) - { - return ~( MemoryPropertyFlags( bits ) ); - } - - template <> struct FlagTraits<MemoryPropertyFlagBits> - { - enum - { - allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated) - }; - }; - - struct MemoryType - { - operator const VkMemoryType&() const - { - return *reinterpret_cast<const VkMemoryType*>(this); - } - - bool operator==( MemoryType const& rhs ) const - { - return ( propertyFlags == rhs.propertyFlags ) - && ( heapIndex == rhs.heapIndex ); - } - - bool operator!=( MemoryType const& rhs ) const - { - return !operator==( rhs ); - } - - MemoryPropertyFlags propertyFlags; - uint32_t heapIndex; - }; - static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); - - enum class MemoryHeapFlagBits - { - eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, - eMultiInstanceKHX = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX - }; - - using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>; - - VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 ) - { - return MemoryHeapFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits ) - { - return ~( MemoryHeapFlags( bits ) ); - } - - template <> struct FlagTraits<MemoryHeapFlagBits> - { - enum - { - allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstanceKHX) - }; - }; - - struct MemoryHeap - { - operator const VkMemoryHeap&() const - { - return *reinterpret_cast<const VkMemoryHeap*>(this); - } - - bool operator==( MemoryHeap const& rhs ) const - { - return ( size == rhs.size ) - && ( flags == rhs.flags ); - } - - bool operator!=( MemoryHeap const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize size; - MemoryHeapFlags flags; - }; - static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMemoryProperties - { - operator const VkPhysicalDeviceMemoryProperties&() const - { - return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this); - } - - bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const - { - return ( memoryTypeCount == rhs.memoryTypeCount ) - && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 ) - && ( memoryHeapCount == rhs.memoryHeapCount ) - && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 ); - } - - bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t memoryTypeCount; - MemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceMemoryProperties2KHR - { - operator const VkPhysicalDeviceMemoryProperties2KHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2KHR*>(this); - } - - bool operator==( PhysicalDeviceMemoryProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryProperties == rhs.memoryProperties ); - } - - bool operator!=( PhysicalDeviceMemoryProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2KHR; - - public: - void* pNext = nullptr; - PhysicalDeviceMemoryProperties memoryProperties; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" ); - - enum class AccessFlagBits - { - eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, - eIndexRead = VK_ACCESS_INDEX_READ_BIT, - eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, - eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, - eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, - eShaderRead = VK_ACCESS_SHADER_READ_BIT, - eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, - eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, - eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, - eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, - eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, - eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, - eHostRead = VK_ACCESS_HOST_READ_BIT, - eHostWrite = VK_ACCESS_HOST_WRITE_BIT, - eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, - eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, - eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, - eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, - eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT - }; - - using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>; - - VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 ) - { - return AccessFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits ) - { - return ~( AccessFlags( bits ) ); - } - - template <> struct FlagTraits<AccessFlagBits> - { - enum - { - allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) - }; - }; - - struct MemoryBarrier - { - MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() ) - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - { - } - - MemoryBarrier( VkMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryBarrier ) ); - } - - MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryBarrier ) ); - return *this; - } - MemoryBarrier& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - operator const VkMemoryBarrier&() const - { - return *reinterpret_cast<const VkMemoryBarrier*>(this); - } - - bool operator==( MemoryBarrier const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ); - } - - bool operator!=( MemoryBarrier const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryBarrier; - - public: - const void* pNext = nullptr; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - }; - static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); - - struct BufferMemoryBarrier - { - BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 ) - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , buffer( buffer_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); - } - - BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); - return *this; - } - BufferMemoryBarrier& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - BufferMemoryBarrier& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - BufferMemoryBarrier& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - BufferMemoryBarrier& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - operator const VkBufferMemoryBarrier&() const - { - return *reinterpret_cast<const VkBufferMemoryBarrier*>(this); - } - - bool operator==( BufferMemoryBarrier const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) - && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) - && ( buffer == rhs.buffer ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( BufferMemoryBarrier const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferMemoryBarrier; - - public: - const void* pNext = nullptr; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - Buffer buffer; - DeviceSize offset; - DeviceSize size; - }; - static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); - - enum class BufferUsageFlagBits - { - eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, - eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, - eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, - eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, - eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT - }; - - using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>; - - VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 ) - { - return BufferUsageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits ) - { - return ~( BufferUsageFlags( bits ) ); - } - - template <> struct FlagTraits<BufferUsageFlagBits> - { - enum - { - allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer) - }; - }; - - enum class BufferCreateFlagBits - { - eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT - }; - - using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>; - - VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 ) - { - return BufferCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits ) - { - return ~( BufferCreateFlags( bits ) ); - } - - template <> struct FlagTraits<BufferCreateFlagBits> - { - enum - { - allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased) - }; - }; - - struct BufferCreateInfo - { - BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) - : flags( flags_ ) - , size( size_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - { - } - - BufferCreateInfo( VkBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); - } - - BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); - return *this; - } - BufferCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BufferCreateInfo& setFlags( BufferCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - BufferCreateInfo& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - BufferCreateInfo& setUsage( BufferUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - BufferCreateInfo& setSharingMode( SharingMode sharingMode_ ) - { - sharingMode = sharingMode_; - return *this; - } - - BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - operator const VkBufferCreateInfo&() const - { - return *reinterpret_cast<const VkBufferCreateInfo*>(this); - } - - bool operator==( BufferCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( size == rhs.size ) - && ( usage == rhs.usage ) - && ( sharingMode == rhs.sharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); - } - - bool operator!=( BufferCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBufferCreateInfo; - - public: - const void* pNext = nullptr; - BufferCreateFlags flags; - DeviceSize size; - BufferUsageFlags usage; - SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - }; - static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); - - enum class ShaderStageFlagBits - { - eVertex = VK_SHADER_STAGE_VERTEX_BIT, - eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, - eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, - eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, - eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, - eCompute = VK_SHADER_STAGE_COMPUTE_BIT, - eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, - eAll = VK_SHADER_STAGE_ALL - }; - - using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>; - - VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 ) - { - return ShaderStageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits ) - { - return ~( ShaderStageFlags( bits ) ); - } - - template <> struct FlagTraits<ShaderStageFlagBits> - { - enum - { - allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll) - }; - }; - - struct DescriptorSetLayoutBinding - { - DescriptorSetLayoutBinding( uint32_t binding_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0, ShaderStageFlags stageFlags_ = ShaderStageFlags(), const Sampler* pImmutableSamplers_ = nullptr ) - : binding( binding_ ) - , descriptorType( descriptorType_ ) - , descriptorCount( descriptorCount_ ) - , stageFlags( stageFlags_ ) - , pImmutableSamplers( pImmutableSamplers_ ) - { - } - - DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); - } - - DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); - return *this; - } - DescriptorSetLayoutBinding& setBinding( uint32_t binding_ ) - { - binding = binding_; - return *this; - } - - DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ ) - { - descriptorType = descriptorType_; - return *this; - } - - DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ ) - { - descriptorCount = descriptorCount_; - return *this; - } - - DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ ) - { - stageFlags = stageFlags_; - return *this; - } - - DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ ) - { - pImmutableSamplers = pImmutableSamplers_; - return *this; - } - - operator const VkDescriptorSetLayoutBinding&() const - { - return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this); - } - - bool operator==( DescriptorSetLayoutBinding const& rhs ) const - { - return ( binding == rhs.binding ) - && ( descriptorType == rhs.descriptorType ) - && ( descriptorCount == rhs.descriptorCount ) - && ( stageFlags == rhs.stageFlags ) - && ( pImmutableSamplers == rhs.pImmutableSamplers ); - } - - bool operator!=( DescriptorSetLayoutBinding const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t binding; - DescriptorType descriptorType; - uint32_t descriptorCount; - ShaderStageFlags stageFlags; - const Sampler* pImmutableSamplers; - }; - static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); - - struct PipelineShaderStageCreateInfo - { - PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr ) - : flags( flags_ ) - , stage( stage_ ) - , module( module_ ) - , pName( pName_ ) - , pSpecializationInfo( pSpecializationInfo_ ) - { - } - - PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); - } - - PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); - return *this; - } - PipelineShaderStageCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ ) - { - stage = stage_; - return *this; - } - - PipelineShaderStageCreateInfo& setModule( ShaderModule module_ ) - { - module = module_; - return *this; - } - - PipelineShaderStageCreateInfo& setPName( const char* pName_ ) - { - pName = pName_; - return *this; - } - - PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ ) - { - pSpecializationInfo = pSpecializationInfo_; - return *this; - } - - operator const VkPipelineShaderStageCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this); - } - - bool operator==( PipelineShaderStageCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stage == rhs.stage ) - && ( module == rhs.module ) - && ( pName == rhs.pName ) - && ( pSpecializationInfo == rhs.pSpecializationInfo ); - } - - bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineShaderStageCreateInfo; - - public: - const void* pNext = nullptr; - PipelineShaderStageCreateFlags flags; - ShaderStageFlagBits stage; - ShaderModule module; - const char* pName; - const SpecializationInfo* pSpecializationInfo; - }; - static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); - - struct PushConstantRange - { - PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), uint32_t offset_ = 0, uint32_t size_ = 0 ) - : stageFlags( stageFlags_ ) - , offset( offset_ ) - , size( size_ ) - { - } - - PushConstantRange( VkPushConstantRange const & rhs ) - { - memcpy( this, &rhs, sizeof( PushConstantRange ) ); - } - - PushConstantRange& operator=( VkPushConstantRange const & rhs ) - { - memcpy( this, &rhs, sizeof( PushConstantRange ) ); - return *this; - } - PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ ) - { - stageFlags = stageFlags_; - return *this; - } - - PushConstantRange& setOffset( uint32_t offset_ ) - { - offset = offset_; - return *this; - } - - PushConstantRange& setSize( uint32_t size_ ) - { - size = size_; - return *this; - } - - operator const VkPushConstantRange&() const - { - return *reinterpret_cast<const VkPushConstantRange*>(this); - } - - bool operator==( PushConstantRange const& rhs ) const - { - return ( stageFlags == rhs.stageFlags ) - && ( offset == rhs.offset ) - && ( size == rhs.size ); - } - - bool operator!=( PushConstantRange const& rhs ) const - { - return !operator==( rhs ); - } - - ShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; - }; - static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); - - struct PipelineLayoutCreateInfo - { - PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr ) - : flags( flags_ ) - , setLayoutCount( setLayoutCount_ ) - , pSetLayouts( pSetLayouts_ ) - , pushConstantRangeCount( pushConstantRangeCount_ ) - , pPushConstantRanges( pPushConstantRanges_ ) - { - } - - PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); - } - - PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); - return *this; - } - PipelineLayoutCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ ) - { - setLayoutCount = setLayoutCount_; - return *this; - } - - PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ ) - { - pSetLayouts = pSetLayouts_; - return *this; - } - - PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) - { - pushConstantRangeCount = pushConstantRangeCount_; - return *this; - } - - PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ ) - { - pPushConstantRanges = pPushConstantRanges_; - return *this; - } - - operator const VkPipelineLayoutCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this); - } - - bool operator==( PipelineLayoutCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( setLayoutCount == rhs.setLayoutCount ) - && ( pSetLayouts == rhs.pSetLayouts ) - && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) - && ( pPushConstantRanges == rhs.pPushConstantRanges ); - } - - bool operator!=( PipelineLayoutCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineLayoutCreateInfo; - - public: - const void* pNext = nullptr; - PipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const DescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const PushConstantRange* pPushConstantRanges; - }; - static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); - - struct ShaderStatisticsInfoAMD - { - operator const VkShaderStatisticsInfoAMD&() const - { - return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this); - } - - bool operator==( ShaderStatisticsInfoAMD const& rhs ) const - { - return ( shaderStageMask == rhs.shaderStageMask ) - && ( resourceUsage == rhs.resourceUsage ) - && ( numPhysicalVgprs == rhs.numPhysicalVgprs ) - && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) - && ( numAvailableVgprs == rhs.numAvailableVgprs ) - && ( numAvailableSgprs == rhs.numAvailableSgprs ) - && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ); - } - - bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const - { - return !operator==( rhs ); - } - - ShaderStageFlags shaderStageMask; - ShaderResourceUsageAMD resourceUsage; - uint32_t numPhysicalVgprs; - uint32_t numPhysicalSgprs; - uint32_t numAvailableVgprs; - uint32_t numAvailableSgprs; - uint32_t computeWorkGroupSize[3]; - }; - static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" ); - - enum class ImageUsageFlagBits - { - eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, - eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, - eStorage = VK_IMAGE_USAGE_STORAGE_BIT, - eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, - eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT - }; - - using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>; - - VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 ) - { - return ImageUsageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits ) - { - return ~( ImageUsageFlags( bits ) ); - } - - template <> struct FlagTraits<ImageUsageFlagBits> - { - enum - { - allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment) - }; - }; - - struct SharedPresentSurfaceCapabilitiesKHR - { - operator const VkSharedPresentSurfaceCapabilitiesKHR&() const - { - return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this); - } - - bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); - } - - bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; - - public: - void* pNext = nullptr; - ImageUsageFlags sharedPresentSupportedUsageFlags; - }; - static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); - - struct ImageViewUsageCreateInfoKHR - { - ImageViewUsageCreateInfoKHR( ImageUsageFlags usage_ = ImageUsageFlags() ) - : usage( usage_ ) - { - } - - ImageViewUsageCreateInfoKHR( VkImageViewUsageCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfoKHR ) ); - } - - ImageViewUsageCreateInfoKHR& operator=( VkImageViewUsageCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfoKHR ) ); - return *this; - } - ImageViewUsageCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageViewUsageCreateInfoKHR& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - operator const VkImageViewUsageCreateInfoKHR&() const - { - return *reinterpret_cast<const VkImageViewUsageCreateInfoKHR*>(this); - } - - bool operator==( ImageViewUsageCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( usage == rhs.usage ); - } - - bool operator!=( ImageViewUsageCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageViewUsageCreateInfoKHR; - - public: - const void* pNext = nullptr; - ImageUsageFlags usage; - }; - static_assert( sizeof( ImageViewUsageCreateInfoKHR ) == sizeof( VkImageViewUsageCreateInfoKHR ), "struct and wrapper have different size!" ); - - enum class ImageCreateFlagBits - { - eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, - eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, - eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, - eBindSfrKHX = VK_IMAGE_CREATE_BIND_SFR_BIT_KHX, - e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, - eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, - eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, - eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, - eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR, - eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR - }; - - using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>; - - VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 ) - { - return ImageCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits ) - { - return ~( ImageCreateFlags( bits ) ); - } - - template <> struct FlagTraits<ImageCreateFlagBits> - { - enum - { - allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eBindSfrKHX) | VkFlags(ImageCreateFlagBits::e2DArrayCompatibleKHR) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatibleKHR) | VkFlags(ImageCreateFlagBits::eExtendedUsageKHR) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) | VkFlags(ImageCreateFlagBits::eDisjointKHR) | VkFlags(ImageCreateFlagBits::eAliasKHR) - }; - }; - - struct PhysicalDeviceImageFormatInfo2KHR - { - PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() ) - : format( format_ ) - , type( type_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , flags( flags_ ) - { - } - - PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); - } - - PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); - return *this; - } - PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceImageFormatInfo2KHR& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - PhysicalDeviceImageFormatInfo2KHR& setType( ImageType type_ ) - { - type = type_; - return *this; - } - - PhysicalDeviceImageFormatInfo2KHR& setTiling( ImageTiling tiling_ ) - { - tiling = tiling_; - return *this; - } - - PhysicalDeviceImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - PhysicalDeviceImageFormatInfo2KHR& setFlags( ImageCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkPhysicalDeviceImageFormatInfo2KHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>(this); - } - - bool operator==( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( type == rhs.type ) - && ( tiling == rhs.tiling ) - && ( usage == rhs.usage ) - && ( flags == rhs.flags ); - } - - bool operator!=( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2KHR; - - public: - const void* pNext = nullptr; - Format format; - ImageType type; - ImageTiling tiling; - ImageUsageFlags usage; - ImageCreateFlags flags; - }; - static_assert( sizeof( PhysicalDeviceImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceImageFormatInfo2KHR ), "struct and wrapper have different size!" ); - - enum class PipelineCreateFlagBits - { - eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, - eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, - eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, - eViewIndexFromDeviceIndexKHX = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX, - eDispatchBaseKHX = VK_PIPELINE_CREATE_DISPATCH_BASE_KHX - }; - - using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>; - - VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 ) - { - return PipelineCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits ) - { - return ~( PipelineCreateFlags( bits ) ); - } - - template <> struct FlagTraits<PipelineCreateFlagBits> - { - enum - { - allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) | VkFlags(PipelineCreateFlagBits::eDispatchBaseKHX) - }; - }; - - struct ComputePipelineCreateInfo - { - ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 ) - : flags( flags_ ) - , stage( stage_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } - - ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); - } - - ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); - return *this; - } - ComputePipelineCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ ) - { - stage = stage_; - return *this; - } - - ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ ) - { - layout = layout_; - return *this; - } - - ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - operator const VkComputePipelineCreateInfo&() const - { - return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this); - } - - bool operator==( ComputePipelineCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stage == rhs.stage ) - && ( layout == rhs.layout ) - && ( basePipelineHandle == rhs.basePipelineHandle ) - && ( basePipelineIndex == rhs.basePipelineIndex ); - } - - bool operator!=( ComputePipelineCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eComputePipelineCreateInfo; - - public: - const void* pNext = nullptr; - PipelineCreateFlags flags; - PipelineShaderStageCreateInfo stage; - PipelineLayout layout; - Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); - - enum class ColorComponentFlagBits - { - eR = VK_COLOR_COMPONENT_R_BIT, - eG = VK_COLOR_COMPONENT_G_BIT, - eB = VK_COLOR_COMPONENT_B_BIT, - eA = VK_COLOR_COMPONENT_A_BIT - }; - - using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>; - - VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 ) - { - return ColorComponentFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits ) - { - return ~( ColorComponentFlags( bits ) ); - } - - template <> struct FlagTraits<ColorComponentFlagBits> - { - enum - { - allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA) - }; - }; - - struct PipelineColorBlendAttachmentState - { - 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() ) - : blendEnable( blendEnable_ ) - , srcColorBlendFactor( srcColorBlendFactor_ ) - , dstColorBlendFactor( dstColorBlendFactor_ ) - , colorBlendOp( colorBlendOp_ ) - , srcAlphaBlendFactor( srcAlphaBlendFactor_ ) - , dstAlphaBlendFactor( dstAlphaBlendFactor_ ) - , alphaBlendOp( alphaBlendOp_ ) - , colorWriteMask( colorWriteMask_ ) - { - } - - PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); - } - - PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); - return *this; - } - PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ ) - { - blendEnable = blendEnable_; - return *this; - } - - PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) - { - srcColorBlendFactor = srcColorBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) - { - dstColorBlendFactor = dstColorBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ ) - { - colorBlendOp = colorBlendOp_; - return *this; - } - - PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) - { - srcAlphaBlendFactor = srcAlphaBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) - { - dstAlphaBlendFactor = dstAlphaBlendFactor_; - return *this; - } - - PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ ) - { - alphaBlendOp = alphaBlendOp_; - return *this; - } - - PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ ) - { - colorWriteMask = colorWriteMask_; - return *this; - } - - operator const VkPipelineColorBlendAttachmentState&() const - { - return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this); - } - - bool operator==( PipelineColorBlendAttachmentState const& rhs ) const - { - return ( blendEnable == rhs.blendEnable ) - && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) - && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) - && ( colorBlendOp == rhs.colorBlendOp ) - && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) - && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) - && ( alphaBlendOp == rhs.alphaBlendOp ) - && ( colorWriteMask == rhs.colorWriteMask ); - } - - bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const - { - return !operator==( rhs ); - } - - Bool32 blendEnable; - BlendFactor srcColorBlendFactor; - BlendFactor dstColorBlendFactor; - BlendOp colorBlendOp; - BlendFactor srcAlphaBlendFactor; - BlendFactor dstAlphaBlendFactor; - BlendOp alphaBlendOp; - ColorComponentFlags colorWriteMask; - }; - static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); - - struct PipelineColorBlendStateCreateInfo - { - 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 } } ) - : flags( flags_ ) - , logicOpEnable( logicOpEnable_ ) - , logicOp( logicOp_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - { - memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); - } - - PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); - } - - PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); - return *this; - } - PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ ) - { - logicOpEnable = logicOpEnable_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ ) - { - logicOp = logicOp_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) - { - attachmentCount = attachmentCount_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ ) - { - pAttachments = pAttachments_; - return *this; - } - - PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ ) - { - memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) ); - return *this; - } - - operator const VkPipelineColorBlendStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this); - } - - bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( logicOpEnable == rhs.logicOpEnable ) - && ( logicOp == rhs.logicOp ) - && ( attachmentCount == rhs.attachmentCount ) - && ( pAttachments == rhs.pAttachments ) - && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 ); - } - - bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineColorBlendStateCreateFlags flags; - Bool32 logicOpEnable; - LogicOp logicOp; - uint32_t attachmentCount; - const PipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; - }; - static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); - - enum class FenceCreateFlagBits - { - eSignaled = VK_FENCE_CREATE_SIGNALED_BIT - }; - - using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>; - - VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 ) - { - return FenceCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits ) - { - return ~( FenceCreateFlags( bits ) ); - } - - template <> struct FlagTraits<FenceCreateFlagBits> - { - enum - { - allFlags = VkFlags(FenceCreateFlagBits::eSignaled) - }; - }; - - struct FenceCreateInfo - { - FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() ) - : flags( flags_ ) - { - } - - FenceCreateInfo( VkFenceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); - } - - FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); - return *this; - } - FenceCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FenceCreateInfo& setFlags( FenceCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkFenceCreateInfo&() const - { - return *reinterpret_cast<const VkFenceCreateInfo*>(this); - } - - bool operator==( FenceCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ); - } - - bool operator!=( FenceCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFenceCreateInfo; - - public: - const void* pNext = nullptr; - FenceCreateFlags flags; - }; - static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); - - enum class FormatFeatureFlagBits - { - eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, - eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, - eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, - eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, - eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, - eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, - eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, - eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, - eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, - eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, - eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, - eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, - eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, - eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, - eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, - eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT, - eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, - eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, - eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, - eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, - eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, - eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR, - eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR - }; - - using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>; - - VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 ) - { - return FormatFeatureFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits ) - { - return ~( FormatFeatureFlags( bits ) ); - } - - template <> struct FlagTraits<FormatFeatureFlagBits> - { - enum - { - allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamplesKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilterKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilterKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR) | VkFlags(FormatFeatureFlagBits::eDisjointKHR) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamplesKHR) - }; - }; - - struct FormatProperties - { - operator const VkFormatProperties&() const - { - return *reinterpret_cast<const VkFormatProperties*>(this); - } - - bool operator==( FormatProperties const& rhs ) const - { - return ( linearTilingFeatures == rhs.linearTilingFeatures ) - && ( optimalTilingFeatures == rhs.optimalTilingFeatures ) - && ( bufferFeatures == rhs.bufferFeatures ); - } - - bool operator!=( FormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - FormatFeatureFlags linearTilingFeatures; - FormatFeatureFlags optimalTilingFeatures; - FormatFeatureFlags bufferFeatures; - }; - static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); - - struct FormatProperties2KHR - { - operator const VkFormatProperties2KHR&() const - { - return *reinterpret_cast<const VkFormatProperties2KHR*>(this); - } - - bool operator==( FormatProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( formatProperties == rhs.formatProperties ); - } - - bool operator!=( FormatProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFormatProperties2KHR; - - public: - void* pNext = nullptr; - FormatProperties formatProperties; - }; - static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" ); - - enum class QueryControlFlagBits - { - ePrecise = VK_QUERY_CONTROL_PRECISE_BIT - }; - - using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>; - - VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 ) - { - return QueryControlFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits ) - { - return ~( QueryControlFlags( bits ) ); - } - - template <> struct FlagTraits<QueryControlFlagBits> - { - enum - { - allFlags = VkFlags(QueryControlFlagBits::ePrecise) - }; - }; - - enum class QueryResultFlagBits - { - e64 = VK_QUERY_RESULT_64_BIT, - eWait = VK_QUERY_RESULT_WAIT_BIT, - eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, - ePartial = VK_QUERY_RESULT_PARTIAL_BIT - }; - - using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>; - - VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 ) - { - return QueryResultFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits ) - { - return ~( QueryResultFlags( bits ) ); - } - - template <> struct FlagTraits<QueryResultFlagBits> - { - enum - { - allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial) - }; - }; - - enum class CommandBufferUsageFlagBits - { - eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, - eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, - eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT - }; - - using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>; - - VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 ) - { - return CommandBufferUsageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits ) - { - return ~( CommandBufferUsageFlags( bits ) ); - } - - template <> struct FlagTraits<CommandBufferUsageFlagBits> - { - enum - { - allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse) - }; - }; - - enum class QueryPipelineStatisticFlagBits - { - eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, - eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, - eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, - eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, - eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, - eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, - eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, - eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, - eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, - eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, - eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT - }; - - using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>; - - VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 ) - { - return QueryPipelineStatisticFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits ) - { - return ~( QueryPipelineStatisticFlags( bits ) ); - } - - template <> struct FlagTraits<QueryPipelineStatisticFlagBits> - { - enum - { - allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations) - }; - }; - - struct CommandBufferInheritanceInfo - { - CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : renderPass( renderPass_ ) - , subpass( subpass_ ) - , framebuffer( framebuffer_ ) - , occlusionQueryEnable( occlusionQueryEnable_ ) - , queryFlags( queryFlags_ ) - , pipelineStatistics( pipelineStatistics_ ) - { - } - - CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); - } - - CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); - return *this; - } - CommandBufferInheritanceInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ ) - { - subpass = subpass_; - return *this; - } - - CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ ) - { - framebuffer = framebuffer_; - return *this; - } - - CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) - { - occlusionQueryEnable = occlusionQueryEnable_; - return *this; - } - - CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ ) - { - queryFlags = queryFlags_; - return *this; - } - - CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) - { - pipelineStatistics = pipelineStatistics_; - return *this; - } - - operator const VkCommandBufferInheritanceInfo&() const - { - return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this); - } - - bool operator==( CommandBufferInheritanceInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( renderPass == rhs.renderPass ) - && ( subpass == rhs.subpass ) - && ( framebuffer == rhs.framebuffer ) - && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) - && ( queryFlags == rhs.queryFlags ) - && ( pipelineStatistics == rhs.pipelineStatistics ); - } - - bool operator!=( CommandBufferInheritanceInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandBufferInheritanceInfo; - - public: - const void* pNext = nullptr; - RenderPass renderPass; - uint32_t subpass; - Framebuffer framebuffer; - Bool32 occlusionQueryEnable; - QueryControlFlags queryFlags; - QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); - - struct CommandBufferBeginInfo - { - CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) - : flags( flags_ ) - , pInheritanceInfo( pInheritanceInfo_ ) - { - } - - CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); - } - - CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); - return *this; - } - CommandBufferBeginInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ ) - { - flags = flags_; - return *this; - } - - CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ ) - { - pInheritanceInfo = pInheritanceInfo_; - return *this; - } - - operator const VkCommandBufferBeginInfo&() const - { - return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this); - } - - bool operator==( CommandBufferBeginInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pInheritanceInfo == rhs.pInheritanceInfo ); - } - - bool operator!=( CommandBufferBeginInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandBufferBeginInfo; - - public: - const void* pNext = nullptr; - CommandBufferUsageFlags flags; - const CommandBufferInheritanceInfo* pInheritanceInfo; - }; - static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); - - struct QueryPoolCreateInfo - { - QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() ) - : flags( flags_ ) - , queryType( queryType_ ) - , queryCount( queryCount_ ) - , pipelineStatistics( pipelineStatistics_ ) - { - } - - QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); - } - - QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); - return *this; - } - QueryPoolCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - QueryPoolCreateInfo& setQueryType( QueryType queryType_ ) - { - queryType = queryType_; - return *this; - } - - QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ ) - { - queryCount = queryCount_; - return *this; - } - - QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) - { - pipelineStatistics = pipelineStatistics_; - return *this; - } - - operator const VkQueryPoolCreateInfo&() const - { - return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this); - } - - bool operator==( QueryPoolCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queryType == rhs.queryType ) - && ( queryCount == rhs.queryCount ) - && ( pipelineStatistics == rhs.pipelineStatistics ); - } - - bool operator!=( QueryPoolCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eQueryPoolCreateInfo; - - public: - const void* pNext = nullptr; - QueryPoolCreateFlags flags; - QueryType queryType; - uint32_t queryCount; - QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); - - enum class ImageAspectFlagBits - { - eColor = VK_IMAGE_ASPECT_COLOR_BIT, - eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, - eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, - eMetadata = VK_IMAGE_ASPECT_METADATA_BIT, - ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR, - ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR, - ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR - }; - - using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>; - - VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 ) - { - return ImageAspectFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits ) - { - return ~( ImageAspectFlags( bits ) ); - } - - template <> struct FlagTraits<ImageAspectFlagBits> - { - enum - { - allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0KHR) | VkFlags(ImageAspectFlagBits::ePlane1KHR) | VkFlags(ImageAspectFlagBits::ePlane2KHR) - }; - }; - - struct ImageSubresource - { - ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t arrayLayer_ = 0 ) - : aspectMask( aspectMask_ ) - , mipLevel( mipLevel_ ) - , arrayLayer( arrayLayer_ ) - { - } - - ImageSubresource( VkImageSubresource const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresource ) ); - } - - ImageSubresource& operator=( VkImageSubresource const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresource ) ); - return *this; - } - ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ImageSubresource& setMipLevel( uint32_t mipLevel_ ) - { - mipLevel = mipLevel_; - return *this; - } - - ImageSubresource& setArrayLayer( uint32_t arrayLayer_ ) - { - arrayLayer = arrayLayer_; - return *this; - } - - operator const VkImageSubresource&() const - { - return *reinterpret_cast<const VkImageSubresource*>(this); - } - - bool operator==( ImageSubresource const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( mipLevel == rhs.mipLevel ) - && ( arrayLayer == rhs.arrayLayer ); - } - - bool operator!=( ImageSubresource const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t arrayLayer; - }; - static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); - - struct ImageSubresourceLayers - { - ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 ) - : aspectMask( aspectMask_ ) - , mipLevel( mipLevel_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } - - ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); - } - - ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); - return *this; - } - ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ ) - { - mipLevel = mipLevel_; - return *this; - } - - ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ ) - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } - - operator const VkImageSubresourceLayers&() const - { - return *reinterpret_cast<const VkImageSubresourceLayers*>(this); - } - - bool operator==( ImageSubresourceLayers const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( mipLevel == rhs.mipLevel ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } - - bool operator!=( ImageSubresourceLayers const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; - }; - static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" ); - - struct ImageSubresourceRange - { - ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t baseMipLevel_ = 0, uint32_t levelCount_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 ) - : aspectMask( aspectMask_ ) - , baseMipLevel( baseMipLevel_ ) - , levelCount( levelCount_ ) - , baseArrayLayer( baseArrayLayer_ ) - , layerCount( layerCount_ ) - { - } - - ImageSubresourceRange( VkImageSubresourceRange const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); - } - - ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); - return *this; - } - ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ ) - { - baseMipLevel = baseMipLevel_; - return *this; - } - - ImageSubresourceRange& setLevelCount( uint32_t levelCount_ ) - { - levelCount = levelCount_; - return *this; - } - - ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ ) - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - ImageSubresourceRange& setLayerCount( uint32_t layerCount_ ) - { - layerCount = layerCount_; - return *this; - } - - operator const VkImageSubresourceRange&() const - { - return *reinterpret_cast<const VkImageSubresourceRange*>(this); - } - - bool operator==( ImageSubresourceRange const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( baseMipLevel == rhs.baseMipLevel ) - && ( levelCount == rhs.levelCount ) - && ( baseArrayLayer == rhs.baseArrayLayer ) - && ( layerCount == rhs.layerCount ); - } - - bool operator!=( ImageSubresourceRange const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t levelCount; - uint32_t baseArrayLayer; - uint32_t layerCount; - }; - static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); - - struct ImageMemoryBarrier - { - 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() ) - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , oldLayout( oldLayout_ ) - , newLayout( newLayout_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , image( image_ ) - , subresourceRange( subresourceRange_ ) - { - } - - ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); - } - - ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); - return *this; - } - ImageMemoryBarrier& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ ) - { - oldLayout = oldLayout_; - return *this; - } - - ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ ) - { - newLayout = newLayout_; - return *this; - } - - ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - ImageMemoryBarrier& setImage( Image image_ ) - { - image = image_; - return *this; - } - - ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) - { - subresourceRange = subresourceRange_; - return *this; - } - - operator const VkImageMemoryBarrier&() const - { - return *reinterpret_cast<const VkImageMemoryBarrier*>(this); - } - - bool operator==( ImageMemoryBarrier const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( oldLayout == rhs.oldLayout ) - && ( newLayout == rhs.newLayout ) - && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) - && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) - && ( image == rhs.image ) - && ( subresourceRange == rhs.subresourceRange ); - } - - bool operator!=( ImageMemoryBarrier const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageMemoryBarrier; - - public: - const void* pNext = nullptr; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - ImageLayout oldLayout; - ImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - Image image; - ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); - - struct ImageViewCreateInfo - { - ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() ) - : flags( flags_ ) - , image( image_ ) - , viewType( viewType_ ) - , format( format_ ) - , components( components_ ) - , subresourceRange( subresourceRange_ ) - { - } - - ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); - } - - ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); - return *this; - } - ImageViewCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImageViewCreateInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - ImageViewCreateInfo& setViewType( ImageViewType viewType_ ) - { - viewType = viewType_; - return *this; - } - - ImageViewCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - ImageViewCreateInfo& setComponents( ComponentMapping components_ ) - { - components = components_; - return *this; - } - - ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ ) - { - subresourceRange = subresourceRange_; - return *this; - } - - operator const VkImageViewCreateInfo&() const - { - return *reinterpret_cast<const VkImageViewCreateInfo*>(this); - } - - bool operator==( ImageViewCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( image == rhs.image ) - && ( viewType == rhs.viewType ) - && ( format == rhs.format ) - && ( components == rhs.components ) - && ( subresourceRange == rhs.subresourceRange ); - } - - bool operator!=( ImageViewCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageViewCreateInfo; - - public: - const void* pNext = nullptr; - ImageViewCreateFlags flags; - Image image; - ImageViewType viewType; - Format format; - ComponentMapping components; - ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); - - struct ImageCopy - { - ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() ) - : srcSubresource( srcSubresource_ ) - , srcOffset( srcOffset_ ) - , dstSubresource( dstSubresource_ ) - , dstOffset( dstOffset_ ) - , extent( extent_ ) - { - } - - ImageCopy( VkImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCopy ) ); - } - - ImageCopy& operator=( VkImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCopy ) ); - return *this; - } - ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) - { - srcSubresource = srcSubresource_; - return *this; - } - - ImageCopy& setSrcOffset( Offset3D srcOffset_ ) - { - srcOffset = srcOffset_; - return *this; - } - - ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) - { - dstSubresource = dstSubresource_; - return *this; - } - - ImageCopy& setDstOffset( Offset3D dstOffset_ ) - { - dstOffset = dstOffset_; - return *this; - } - - ImageCopy& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - operator const VkImageCopy&() const - { - return *reinterpret_cast<const VkImageCopy*>(this); - } - - bool operator==( ImageCopy const& rhs ) const - { - return ( srcSubresource == rhs.srcSubresource ) - && ( srcOffset == rhs.srcOffset ) - && ( dstSubresource == rhs.dstSubresource ) - && ( dstOffset == rhs.dstOffset ) - && ( extent == rhs.extent ); - } - - bool operator!=( ImageCopy const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresourceLayers srcSubresource; - Offset3D srcOffset; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffset; - Extent3D extent; - }; - static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); - - struct ImageBlit - { - ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } ) - : srcSubresource( srcSubresource_ ) - , dstSubresource( dstSubresource_ ) - { - memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); - memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); - } - - ImageBlit( VkImageBlit const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageBlit ) ); - } - - ImageBlit& operator=( VkImageBlit const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageBlit ) ); - return *this; - } - ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) - { - srcSubresource = srcSubresource_; - return *this; - } - - ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ ) - { - memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) ); - return *this; - } - - ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) - { - dstSubresource = dstSubresource_; - return *this; - } - - ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ ) - { - memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) ); - return *this; - } - - operator const VkImageBlit&() const - { - return *reinterpret_cast<const VkImageBlit*>(this); - } - - bool operator==( ImageBlit const& rhs ) const - { - return ( srcSubresource == rhs.srcSubresource ) - && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 ) - && ( dstSubresource == rhs.dstSubresource ) - && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 ); - } - - bool operator!=( ImageBlit const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresourceLayers srcSubresource; - Offset3D srcOffsets[2]; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffsets[2]; - }; - static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); - - struct BufferImageCopy - { - BufferImageCopy( DeviceSize bufferOffset_ = 0, uint32_t bufferRowLength_ = 0, uint32_t bufferImageHeight_ = 0, ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), Offset3D imageOffset_ = Offset3D(), Extent3D imageExtent_ = Extent3D() ) - : bufferOffset( bufferOffset_ ) - , bufferRowLength( bufferRowLength_ ) - , bufferImageHeight( bufferImageHeight_ ) - , imageSubresource( imageSubresource_ ) - , imageOffset( imageOffset_ ) - , imageExtent( imageExtent_ ) - { - } - - BufferImageCopy( VkBufferImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferImageCopy ) ); - } - - BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) - { - memcpy( this, &rhs, sizeof( BufferImageCopy ) ); - return *this; - } - BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ ) - { - bufferOffset = bufferOffset_; - return *this; - } - - BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ ) - { - bufferRowLength = bufferRowLength_; - return *this; - } - - BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ ) - { - bufferImageHeight = bufferImageHeight_; - return *this; - } - - BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ ) - { - imageSubresource = imageSubresource_; - return *this; - } - - BufferImageCopy& setImageOffset( Offset3D imageOffset_ ) - { - imageOffset = imageOffset_; - return *this; - } - - BufferImageCopy& setImageExtent( Extent3D imageExtent_ ) - { - imageExtent = imageExtent_; - return *this; - } - - operator const VkBufferImageCopy&() const - { - return *reinterpret_cast<const VkBufferImageCopy*>(this); - } - - bool operator==( BufferImageCopy const& rhs ) const - { - return ( bufferOffset == rhs.bufferOffset ) - && ( bufferRowLength == rhs.bufferRowLength ) - && ( bufferImageHeight == rhs.bufferImageHeight ) - && ( imageSubresource == rhs.imageSubresource ) - && ( imageOffset == rhs.imageOffset ) - && ( imageExtent == rhs.imageExtent ); - } - - bool operator!=( BufferImageCopy const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - ImageSubresourceLayers imageSubresource; - Offset3D imageOffset; - Extent3D imageExtent; - }; - static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); - - struct ImageResolve - { - ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() ) - : srcSubresource( srcSubresource_ ) - , srcOffset( srcOffset_ ) - , dstSubresource( dstSubresource_ ) - , dstOffset( dstOffset_ ) - , extent( extent_ ) - { - } - - ImageResolve( VkImageResolve const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageResolve ) ); - } - - ImageResolve& operator=( VkImageResolve const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageResolve ) ); - return *this; - } - ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) - { - srcSubresource = srcSubresource_; - return *this; - } - - ImageResolve& setSrcOffset( Offset3D srcOffset_ ) - { - srcOffset = srcOffset_; - return *this; - } - - ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ ) - { - dstSubresource = dstSubresource_; - return *this; - } - - ImageResolve& setDstOffset( Offset3D dstOffset_ ) - { - dstOffset = dstOffset_; - return *this; - } - - ImageResolve& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - operator const VkImageResolve&() const - { - return *reinterpret_cast<const VkImageResolve*>(this); - } - - bool operator==( ImageResolve const& rhs ) const - { - return ( srcSubresource == rhs.srcSubresource ) - && ( srcOffset == rhs.srcOffset ) - && ( dstSubresource == rhs.dstSubresource ) - && ( dstOffset == rhs.dstOffset ) - && ( extent == rhs.extent ); - } - - bool operator!=( ImageResolve const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresourceLayers srcSubresource; - Offset3D srcOffset; - ImageSubresourceLayers dstSubresource; - Offset3D dstOffset; - Extent3D extent; - }; - static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); - - struct ClearAttachment - { - ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t colorAttachment_ = 0, ClearValue clearValue_ = ClearValue() ) - : aspectMask( aspectMask_ ) - , colorAttachment( colorAttachment_ ) - , clearValue( clearValue_ ) - { - } - - ClearAttachment( VkClearAttachment const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearAttachment ) ); - } - - ClearAttachment& operator=( VkClearAttachment const & rhs ) - { - memcpy( this, &rhs, sizeof( ClearAttachment ) ); - return *this; - } - ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - ClearAttachment& setColorAttachment( uint32_t colorAttachment_ ) - { - colorAttachment = colorAttachment_; - return *this; - } - - ClearAttachment& setClearValue( ClearValue clearValue_ ) - { - clearValue = clearValue_; - return *this; - } - - operator const VkClearAttachment&() const - { - return *reinterpret_cast<const VkClearAttachment*>(this); - } - - ImageAspectFlags aspectMask; - uint32_t colorAttachment; - ClearValue clearValue; - }; - static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); - - struct InputAttachmentAspectReferenceKHR - { - InputAttachmentAspectReferenceKHR( uint32_t subpass_ = 0, uint32_t inputAttachmentIndex_ = 0, ImageAspectFlags aspectMask_ = ImageAspectFlags() ) - : subpass( subpass_ ) - , inputAttachmentIndex( inputAttachmentIndex_ ) - , aspectMask( aspectMask_ ) - { - } - - InputAttachmentAspectReferenceKHR( VkInputAttachmentAspectReferenceKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( InputAttachmentAspectReferenceKHR ) ); - } - - InputAttachmentAspectReferenceKHR& operator=( VkInputAttachmentAspectReferenceKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( InputAttachmentAspectReferenceKHR ) ); - return *this; - } - InputAttachmentAspectReferenceKHR& setSubpass( uint32_t subpass_ ) - { - subpass = subpass_; - return *this; - } - - InputAttachmentAspectReferenceKHR& setInputAttachmentIndex( uint32_t inputAttachmentIndex_ ) - { - inputAttachmentIndex = inputAttachmentIndex_; - return *this; - } - - InputAttachmentAspectReferenceKHR& setAspectMask( ImageAspectFlags aspectMask_ ) - { - aspectMask = aspectMask_; - return *this; - } - - operator const VkInputAttachmentAspectReferenceKHR&() const - { - return *reinterpret_cast<const VkInputAttachmentAspectReferenceKHR*>(this); - } - - bool operator==( InputAttachmentAspectReferenceKHR const& rhs ) const - { - return ( subpass == rhs.subpass ) - && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) - && ( aspectMask == rhs.aspectMask ); - } - - bool operator!=( InputAttachmentAspectReferenceKHR const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t subpass; - uint32_t inputAttachmentIndex; - ImageAspectFlags aspectMask; - }; - static_assert( sizeof( InputAttachmentAspectReferenceKHR ) == sizeof( VkInputAttachmentAspectReferenceKHR ), "struct and wrapper have different size!" ); - - struct RenderPassInputAttachmentAspectCreateInfoKHR - { - RenderPassInputAttachmentAspectCreateInfoKHR( uint32_t aspectReferenceCount_ = 0, const InputAttachmentAspectReferenceKHR* pAspectReferences_ = nullptr ) - : aspectReferenceCount( aspectReferenceCount_ ) - , pAspectReferences( pAspectReferences_ ) - { - } - - RenderPassInputAttachmentAspectCreateInfoKHR( VkRenderPassInputAttachmentAspectCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfoKHR ) ); - } - - RenderPassInputAttachmentAspectCreateInfoKHR& operator=( VkRenderPassInputAttachmentAspectCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfoKHR ) ); - return *this; - } - RenderPassInputAttachmentAspectCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassInputAttachmentAspectCreateInfoKHR& setAspectReferenceCount( uint32_t aspectReferenceCount_ ) - { - aspectReferenceCount = aspectReferenceCount_; - return *this; - } - - RenderPassInputAttachmentAspectCreateInfoKHR& setPAspectReferences( const InputAttachmentAspectReferenceKHR* pAspectReferences_ ) - { - pAspectReferences = pAspectReferences_; - return *this; - } - - operator const VkRenderPassInputAttachmentAspectCreateInfoKHR&() const - { - return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfoKHR*>(this); - } - - bool operator==( RenderPassInputAttachmentAspectCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( aspectReferenceCount == rhs.aspectReferenceCount ) - && ( pAspectReferences == rhs.pAspectReferences ); - } - - bool operator!=( RenderPassInputAttachmentAspectCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR; - - public: - const void* pNext = nullptr; - uint32_t aspectReferenceCount; - const InputAttachmentAspectReferenceKHR* pAspectReferences; - }; - static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfoKHR ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct BindImagePlaneMemoryInfoKHR - { - BindImagePlaneMemoryInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) - : planeAspect( planeAspect_ ) - { - } - - BindImagePlaneMemoryInfoKHR( VkBindImagePlaneMemoryInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfoKHR ) ); - } - - BindImagePlaneMemoryInfoKHR& operator=( VkBindImagePlaneMemoryInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfoKHR ) ); - return *this; - } - BindImagePlaneMemoryInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindImagePlaneMemoryInfoKHR& setPlaneAspect( ImageAspectFlagBits planeAspect_ ) - { - planeAspect = planeAspect_; - return *this; - } - - operator const VkBindImagePlaneMemoryInfoKHR&() const - { - return *reinterpret_cast<const VkBindImagePlaneMemoryInfoKHR*>(this); - } - - bool operator==( BindImagePlaneMemoryInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( planeAspect == rhs.planeAspect ); - } - - bool operator!=( BindImagePlaneMemoryInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindImagePlaneMemoryInfoKHR; - - public: - const void* pNext = nullptr; - ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( BindImagePlaneMemoryInfoKHR ) == sizeof( VkBindImagePlaneMemoryInfoKHR ), "struct and wrapper have different size!" ); - - struct ImagePlaneMemoryRequirementsInfoKHR - { - ImagePlaneMemoryRequirementsInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor ) - : planeAspect( planeAspect_ ) - { - } - - ImagePlaneMemoryRequirementsInfoKHR( VkImagePlaneMemoryRequirementsInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfoKHR ) ); - } - - ImagePlaneMemoryRequirementsInfoKHR& operator=( VkImagePlaneMemoryRequirementsInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfoKHR ) ); - return *this; - } - ImagePlaneMemoryRequirementsInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImagePlaneMemoryRequirementsInfoKHR& setPlaneAspect( ImageAspectFlagBits planeAspect_ ) - { - planeAspect = planeAspect_; - return *this; - } - - operator const VkImagePlaneMemoryRequirementsInfoKHR&() const - { - return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfoKHR*>(this); - } - - bool operator==( ImagePlaneMemoryRequirementsInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( planeAspect == rhs.planeAspect ); - } - - bool operator!=( ImagePlaneMemoryRequirementsInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfoKHR; - - public: - const void* pNext = nullptr; - ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( ImagePlaneMemoryRequirementsInfoKHR ) == sizeof( VkImagePlaneMemoryRequirementsInfoKHR ), "struct and wrapper have different size!" ); - - enum class SparseImageFormatFlagBits - { - eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, - eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, - eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT - }; - - using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>; - - VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 ) - { - return SparseImageFormatFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits ) - { - return ~( SparseImageFormatFlags( bits ) ); - } - - template <> struct FlagTraits<SparseImageFormatFlagBits> - { - enum - { - allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize) - }; - }; - - struct SparseImageFormatProperties - { - operator const VkSparseImageFormatProperties&() const - { - return *reinterpret_cast<const VkSparseImageFormatProperties*>(this); - } - - bool operator==( SparseImageFormatProperties const& rhs ) const - { - return ( aspectMask == rhs.aspectMask ) - && ( imageGranularity == rhs.imageGranularity ) - && ( flags == rhs.flags ); - } - - bool operator!=( SparseImageFormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - ImageAspectFlags aspectMask; - Extent3D imageGranularity; - SparseImageFormatFlags flags; - }; - static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryRequirements - { - operator const VkSparseImageMemoryRequirements&() const - { - return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this); - } - - bool operator==( SparseImageMemoryRequirements const& rhs ) const - { - return ( formatProperties == rhs.formatProperties ) - && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) - && ( imageMipTailSize == rhs.imageMipTailSize ) - && ( imageMipTailOffset == rhs.imageMipTailOffset ) - && ( imageMipTailStride == rhs.imageMipTailStride ); - } - - bool operator!=( SparseImageMemoryRequirements const& rhs ) const - { - return !operator==( rhs ); - } - - SparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - DeviceSize imageMipTailSize; - DeviceSize imageMipTailOffset; - DeviceSize imageMipTailStride; - }; - static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); - - struct SparseImageFormatProperties2KHR - { - operator const VkSparseImageFormatProperties2KHR&() const - { - return *reinterpret_cast<const VkSparseImageFormatProperties2KHR*>(this); - } - - bool operator==( SparseImageFormatProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( properties == rhs.properties ); - } - - bool operator!=( SparseImageFormatProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSparseImageFormatProperties2KHR; - - public: - void* pNext = nullptr; - SparseImageFormatProperties properties; - }; - static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryRequirements2KHR - { - operator const VkSparseImageMemoryRequirements2KHR&() const - { - return *reinterpret_cast<const VkSparseImageMemoryRequirements2KHR*>(this); - } - - bool operator==( SparseImageMemoryRequirements2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryRequirements == rhs.memoryRequirements ); - } - - bool operator!=( SparseImageMemoryRequirements2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSparseImageMemoryRequirements2KHR; - - public: - void* pNext = nullptr; - SparseImageMemoryRequirements memoryRequirements; - }; - static_assert( sizeof( SparseImageMemoryRequirements2KHR ) == sizeof( VkSparseImageMemoryRequirements2KHR ), "struct and wrapper have different size!" ); - - enum class SparseMemoryBindFlagBits - { - eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT - }; - - using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>; - - VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 ) - { - return SparseMemoryBindFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits ) - { - return ~( SparseMemoryBindFlags( bits ) ); - } - - template <> struct FlagTraits<SparseMemoryBindFlagBits> - { - enum - { - allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata) - }; - }; - - struct SparseMemoryBind - { - SparseMemoryBind( DeviceSize resourceOffset_ = 0, DeviceSize size_ = 0, DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) - : resourceOffset( resourceOffset_ ) - , size( size_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , flags( flags_ ) - { - } - - SparseMemoryBind( VkSparseMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); - } - - SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); - return *this; - } - SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ ) - { - resourceOffset = resourceOffset_; - return *this; - } - - SparseMemoryBind& setSize( DeviceSize size_ ) - { - size = size_; - return *this; - } - - SparseMemoryBind& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkSparseMemoryBind&() const - { - return *reinterpret_cast<const VkSparseMemoryBind*>(this); - } - - bool operator==( SparseMemoryBind const& rhs ) const - { - return ( resourceOffset == rhs.resourceOffset ) - && ( size == rhs.size ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ) - && ( flags == rhs.flags ); - } - - bool operator!=( SparseMemoryBind const& rhs ) const - { - return !operator==( rhs ); - } - - DeviceSize resourceOffset; - DeviceSize size; - DeviceMemory memory; - DeviceSize memoryOffset; - SparseMemoryBindFlags flags; - }; - static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryBind - { - SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), Offset3D offset_ = Offset3D(), Extent3D extent_ = Extent3D(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() ) - : subresource( subresource_ ) - , offset( offset_ ) - , extent( extent_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , flags( flags_ ) - { - } - - SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); - } - - SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); - return *this; - } - SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ ) - { - subresource = subresource_; - return *this; - } - - SparseImageMemoryBind& setOffset( Offset3D offset_ ) - { - offset = offset_; - return *this; - } - - SparseImageMemoryBind& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - SparseImageMemoryBind& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ ) - { - memoryOffset = memoryOffset_; - return *this; - } - - SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkSparseImageMemoryBind&() const - { - return *reinterpret_cast<const VkSparseImageMemoryBind*>(this); - } - - bool operator==( SparseImageMemoryBind const& rhs ) const - { - return ( subresource == rhs.subresource ) - && ( offset == rhs.offset ) - && ( extent == rhs.extent ) - && ( memory == rhs.memory ) - && ( memoryOffset == rhs.memoryOffset ) - && ( flags == rhs.flags ); - } - - bool operator!=( SparseImageMemoryBind const& rhs ) const - { - return !operator==( rhs ); - } - - ImageSubresource subresource; - Offset3D offset; - Extent3D extent; - DeviceMemory memory; - DeviceSize memoryOffset; - SparseMemoryBindFlags flags; - }; - static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" ); - - struct SparseBufferMemoryBindInfo - { - SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr ) - : buffer( buffer_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) - { - } - - SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); - } - - SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); - return *this; - } - SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ ) - { - bindCount = bindCount_; - return *this; - } - - SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) - { - pBinds = pBinds_; - return *this; - } - - operator const VkSparseBufferMemoryBindInfo&() const - { - return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this); - } - - bool operator==( SparseBufferMemoryBindInfo const& rhs ) const - { - return ( buffer == rhs.buffer ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); - } - - bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Buffer buffer; - uint32_t bindCount; - const SparseMemoryBind* pBinds; - }; - static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" ); - - struct SparseImageOpaqueMemoryBindInfo - { - SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr ) - : image( image_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) - { - } - - SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); - } - - SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); - return *this; - } - SparseImageOpaqueMemoryBindInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ ) - { - bindCount = bindCount_; - return *this; - } - - SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ ) - { - pBinds = pBinds_; - return *this; - } - - operator const VkSparseImageOpaqueMemoryBindInfo&() const - { - return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this); - } - - bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const - { - return ( image == rhs.image ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); - } - - bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Image image; - uint32_t bindCount; - const SparseMemoryBind* pBinds; - }; - static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" ); - - struct SparseImageMemoryBindInfo - { - SparseImageMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseImageMemoryBind* pBinds_ = nullptr ) - : image( image_ ) - , bindCount( bindCount_ ) - , pBinds( pBinds_ ) - { - } - - SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); - } - - SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); - return *this; - } - SparseImageMemoryBindInfo& setImage( Image image_ ) - { - image = image_; - return *this; - } - - SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ ) - { - bindCount = bindCount_; - return *this; - } - - SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ ) - { - pBinds = pBinds_; - return *this; - } - - operator const VkSparseImageMemoryBindInfo&() const - { - return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this); - } - - bool operator==( SparseImageMemoryBindInfo const& rhs ) const - { - return ( image == rhs.image ) - && ( bindCount == rhs.bindCount ) - && ( pBinds == rhs.pBinds ); - } - - bool operator!=( SparseImageMemoryBindInfo const& rhs ) const - { - return !operator==( rhs ); - } - - Image image; - uint32_t bindCount; - const SparseImageMemoryBind* pBinds; - }; - static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); - - struct BindSparseInfo - { - 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 ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , bufferBindCount( bufferBindCount_ ) - , pBufferBinds( pBufferBinds_ ) - , imageOpaqueBindCount( imageOpaqueBindCount_ ) - , pImageOpaqueBinds( pImageOpaqueBinds_ ) - , imageBindCount( imageBindCount_ ) - , pImageBinds( pImageBinds_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - { - } - - BindSparseInfo( VkBindSparseInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindSparseInfo ) ); - } - - BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( BindSparseInfo ) ); - return *this; - } - BindSparseInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ ) - { - bufferBindCount = bufferBindCount_; - return *this; - } - - BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ ) - { - pBufferBinds = pBufferBinds_; - return *this; - } - - BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) - { - imageOpaqueBindCount = imageOpaqueBindCount_; - return *this; - } - - BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ ) - { - pImageOpaqueBinds = pImageOpaqueBinds_; - return *this; - } - - BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ ) - { - imageBindCount = imageBindCount_; - return *this; - } - - BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ ) - { - pImageBinds = pImageBinds_; - return *this; - } - - BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) - { - pSignalSemaphores = pSignalSemaphores_; - return *this; - } - - operator const VkBindSparseInfo&() const - { - return *reinterpret_cast<const VkBindSparseInfo*>(this); - } - - bool operator==( BindSparseInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( bufferBindCount == rhs.bufferBindCount ) - && ( pBufferBinds == rhs.pBufferBinds ) - && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) - && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) - && ( imageBindCount == rhs.imageBindCount ) - && ( pImageBinds == rhs.pImageBinds ) - && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) - && ( pSignalSemaphores == rhs.pSignalSemaphores ); - } - - bool operator!=( BindSparseInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eBindSparseInfo; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const SparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const SparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); - - enum class PipelineStageFlagBits - { - eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, - eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, - eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, - eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, - eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, - eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, - eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, - eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, - eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, - eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, - eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - eHost = VK_PIPELINE_STAGE_HOST_BIT, - eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, - eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX - }; - - using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>; - - VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 ) - { - return PipelineStageFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits ) - { - return ~( PipelineStageFlags( bits ) ); - } - - template <> struct FlagTraits<PipelineStageFlagBits> - { - enum - { - allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX) - }; - }; - - enum class CommandPoolCreateFlagBits - { - eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, - eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT - }; - - using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>; - - VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 ) - { - return CommandPoolCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits ) - { - return ~( CommandPoolCreateFlags( bits ) ); - } - - template <> struct FlagTraits<CommandPoolCreateFlagBits> - { - enum - { - allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer) - }; - }; - - struct CommandPoolCreateInfo - { - CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 ) - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - { - } - - CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); - } - - CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); - return *this; - } - CommandPoolCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - operator const VkCommandPoolCreateInfo&() const - { - return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this); - } - - bool operator==( CommandPoolCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( queueFamilyIndex == rhs.queueFamilyIndex ); - } - - bool operator!=( CommandPoolCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCommandPoolCreateInfo; - - public: - const void* pNext = nullptr; - CommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; - }; - static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); - - enum class CommandPoolResetFlagBits - { - eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT - }; - - using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>; - - VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 ) - { - return CommandPoolResetFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits ) - { - return ~( CommandPoolResetFlags( bits ) ); - } - - template <> struct FlagTraits<CommandPoolResetFlagBits> - { - enum - { - allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources) - }; - }; - - enum class CommandBufferResetFlagBits - { - eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT - }; - - using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>; - - VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 ) - { - return CommandBufferResetFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits ) - { - return ~( CommandBufferResetFlags( bits ) ); - } - - template <> struct FlagTraits<CommandBufferResetFlagBits> - { - enum - { - allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources) - }; - }; - - enum class SampleCountFlagBits - { - e1 = VK_SAMPLE_COUNT_1_BIT, - e2 = VK_SAMPLE_COUNT_2_BIT, - e4 = VK_SAMPLE_COUNT_4_BIT, - e8 = VK_SAMPLE_COUNT_8_BIT, - e16 = VK_SAMPLE_COUNT_16_BIT, - e32 = VK_SAMPLE_COUNT_32_BIT, - e64 = VK_SAMPLE_COUNT_64_BIT - }; - - using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>; - - VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 ) - { - return SampleCountFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits ) - { - return ~( SampleCountFlags( bits ) ); - } - - template <> struct FlagTraits<SampleCountFlagBits> - { - enum - { - allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64) - }; - }; - - struct ImageFormatProperties - { - operator const VkImageFormatProperties&() const - { - return *reinterpret_cast<const VkImageFormatProperties*>(this); - } - - bool operator==( ImageFormatProperties const& rhs ) const - { - return ( maxExtent == rhs.maxExtent ) - && ( maxMipLevels == rhs.maxMipLevels ) - && ( maxArrayLayers == rhs.maxArrayLayers ) - && ( sampleCounts == rhs.sampleCounts ) - && ( maxResourceSize == rhs.maxResourceSize ); - } - - bool operator!=( ImageFormatProperties const& rhs ) const - { - return !operator==( rhs ); - } - - Extent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - SampleCountFlags sampleCounts; - DeviceSize maxResourceSize; - }; - static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" ); - - struct ImageCreateInfo - { - 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 ) - : flags( flags_ ) - , imageType( imageType_ ) - , format( format_ ) - , extent( extent_ ) - , mipLevels( mipLevels_ ) - , arrayLayers( arrayLayers_ ) - , samples( samples_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , initialLayout( initialLayout_ ) - { - } - - ImageCreateInfo( VkImageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); - } - - ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); - return *this; - } - ImageCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImageCreateInfo& setFlags( ImageCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - ImageCreateInfo& setImageType( ImageType imageType_ ) - { - imageType = imageType_; - return *this; - } - - ImageCreateInfo& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - ImageCreateInfo& setExtent( Extent3D extent_ ) - { - extent = extent_; - return *this; - } - - ImageCreateInfo& setMipLevels( uint32_t mipLevels_ ) - { - mipLevels = mipLevels_; - return *this; - } - - ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ ) - { - arrayLayers = arrayLayers_; - return *this; - } - - ImageCreateInfo& setSamples( SampleCountFlagBits samples_ ) - { - samples = samples_; - return *this; - } - - ImageCreateInfo& setTiling( ImageTiling tiling_ ) - { - tiling = tiling_; - return *this; - } - - ImageCreateInfo& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - ImageCreateInfo& setSharingMode( SharingMode sharingMode_ ) - { - sharingMode = sharingMode_; - return *this; - } - - ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ ) - { - initialLayout = initialLayout_; - return *this; - } - - operator const VkImageCreateInfo&() const - { - return *reinterpret_cast<const VkImageCreateInfo*>(this); - } - - bool operator==( ImageCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( imageType == rhs.imageType ) - && ( format == rhs.format ) - && ( extent == rhs.extent ) - && ( mipLevels == rhs.mipLevels ) - && ( arrayLayers == rhs.arrayLayers ) - && ( samples == rhs.samples ) - && ( tiling == rhs.tiling ) - && ( usage == rhs.usage ) - && ( sharingMode == rhs.sharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) - && ( initialLayout == rhs.initialLayout ); - } - - bool operator!=( ImageCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageCreateInfo; - - public: - const void* pNext = nullptr; - ImageCreateFlags flags; - ImageType imageType; - Format format; - Extent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - SampleCountFlagBits samples; - ImageTiling tiling; - ImageUsageFlags usage; - SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - ImageLayout initialLayout; - }; - static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); - - struct PipelineMultisampleStateCreateInfo - { - PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 ) - : flags( flags_ ) - , rasterizationSamples( rasterizationSamples_ ) - , sampleShadingEnable( sampleShadingEnable_ ) - , minSampleShading( minSampleShading_ ) - , pSampleMask( pSampleMask_ ) - , alphaToCoverageEnable( alphaToCoverageEnable_ ) - , alphaToOneEnable( alphaToOneEnable_ ) - { - } - - PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); - } - - PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); - return *this; - } - PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) - { - rasterizationSamples = rasterizationSamples_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ ) - { - sampleShadingEnable = sampleShadingEnable_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ ) - { - minSampleShading = minSampleShading_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ ) - { - pSampleMask = pSampleMask_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) - { - alphaToCoverageEnable = alphaToCoverageEnable_; - return *this; - } - - PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) - { - alphaToOneEnable = alphaToOneEnable_; - return *this; - } - - operator const VkPipelineMultisampleStateCreateInfo&() const - { - return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this); - } - - bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( rasterizationSamples == rhs.rasterizationSamples ) - && ( sampleShadingEnable == rhs.sampleShadingEnable ) - && ( minSampleShading == rhs.minSampleShading ) - && ( pSampleMask == rhs.pSampleMask ) - && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) - && ( alphaToOneEnable == rhs.alphaToOneEnable ); - } - - bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; - - public: - const void* pNext = nullptr; - PipelineMultisampleStateCreateFlags flags; - SampleCountFlagBits rasterizationSamples; - Bool32 sampleShadingEnable; - float minSampleShading; - const SampleMask* pSampleMask; - Bool32 alphaToCoverageEnable; - Bool32 alphaToOneEnable; - }; - static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); - - struct GraphicsPipelineCreateInfo - { - 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 ) - : flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , pVertexInputState( pVertexInputState_ ) - , pInputAssemblyState( pInputAssemblyState_ ) - , pTessellationState( pTessellationState_ ) - , pViewportState( pViewportState_ ) - , pRasterizationState( pRasterizationState_ ) - , pMultisampleState( pMultisampleState_ ) - , pDepthStencilState( pDepthStencilState_ ) - , pColorBlendState( pColorBlendState_ ) - , pDynamicState( pDynamicState_ ) - , layout( layout_ ) - , renderPass( renderPass_ ) - , subpass( subpass_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } - - GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); - } - - GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); - return *this; - } - GraphicsPipelineCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ ) - { - stageCount = stageCount_; - return *this; - } - - GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ ) - { - pStages = pStages_; - return *this; - } - - GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ ) - { - pVertexInputState = pVertexInputState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ ) - { - pInputAssemblyState = pInputAssemblyState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ ) - { - pTessellationState = pTessellationState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ ) - { - pViewportState = pViewportState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ ) - { - pRasterizationState = pRasterizationState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ ) - { - pMultisampleState = pMultisampleState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ ) - { - pDepthStencilState = pDepthStencilState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ ) - { - pColorBlendState = pColorBlendState_; - return *this; - } - - GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ ) - { - pDynamicState = pDynamicState_; - return *this; - } - - GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ ) - { - layout = layout_; - return *this; - } - - GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ ) - { - renderPass = renderPass_; - return *this; - } - - GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ ) - { - subpass = subpass_; - return *this; - } - - GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ ) - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ ) - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - operator const VkGraphicsPipelineCreateInfo&() const - { - return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this); - } - - bool operator==( GraphicsPipelineCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( stageCount == rhs.stageCount ) - && ( pStages == rhs.pStages ) - && ( pVertexInputState == rhs.pVertexInputState ) - && ( pInputAssemblyState == rhs.pInputAssemblyState ) - && ( pTessellationState == rhs.pTessellationState ) - && ( pViewportState == rhs.pViewportState ) - && ( pRasterizationState == rhs.pRasterizationState ) - && ( pMultisampleState == rhs.pMultisampleState ) - && ( pDepthStencilState == rhs.pDepthStencilState ) - && ( pColorBlendState == rhs.pColorBlendState ) - && ( pDynamicState == rhs.pDynamicState ) - && ( layout == rhs.layout ) - && ( renderPass == rhs.renderPass ) - && ( subpass == rhs.subpass ) - && ( basePipelineHandle == rhs.basePipelineHandle ) - && ( basePipelineIndex == rhs.basePipelineIndex ); - } - - bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eGraphicsPipelineCreateInfo; - - public: - const void* pNext = nullptr; - PipelineCreateFlags flags; - uint32_t stageCount; - const PipelineShaderStageCreateInfo* pStages; - const PipelineVertexInputStateCreateInfo* pVertexInputState; - const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const PipelineTessellationStateCreateInfo* pTessellationState; - const PipelineViewportStateCreateInfo* pViewportState; - const PipelineRasterizationStateCreateInfo* pRasterizationState; - const PipelineMultisampleStateCreateInfo* pMultisampleState; - const PipelineDepthStencilStateCreateInfo* pDepthStencilState; - const PipelineColorBlendStateCreateInfo* pColorBlendState; - const PipelineDynamicStateCreateInfo* pDynamicState; - PipelineLayout layout; - RenderPass renderPass; - uint32_t subpass; - Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceLimits - { - operator const VkPhysicalDeviceLimits&() const - { - return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this); - } - - bool operator==( PhysicalDeviceLimits const& rhs ) const - { - return ( maxImageDimension1D == rhs.maxImageDimension1D ) - && ( maxImageDimension2D == rhs.maxImageDimension2D ) - && ( maxImageDimension3D == rhs.maxImageDimension3D ) - && ( maxImageDimensionCube == rhs.maxImageDimensionCube ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( maxTexelBufferElements == rhs.maxTexelBufferElements ) - && ( maxUniformBufferRange == rhs.maxUniformBufferRange ) - && ( maxStorageBufferRange == rhs.maxStorageBufferRange ) - && ( maxPushConstantsSize == rhs.maxPushConstantsSize ) - && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) - && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) - && ( bufferImageGranularity == rhs.bufferImageGranularity ) - && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) - && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) - && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) - && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) - && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) - && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) - && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) - && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) - && ( maxPerStageResources == rhs.maxPerStageResources ) - && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) - && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) - && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) - && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) - && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) - && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) - && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) - && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) - && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) - && ( maxVertexInputBindings == rhs.maxVertexInputBindings ) - && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) - && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) - && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) - && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) - && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) - && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) - && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents ) - && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) - && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) - && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) - && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) - && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) - && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) - && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) - && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) - && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) - && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) - && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) - && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) - && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) - && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) - && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 ) - && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) - && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 ) - && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) - && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) - && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) - && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) - && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) - && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) - && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) - && ( maxViewports == rhs.maxViewports ) - && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 ) - && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 ) - && ( viewportSubPixelBits == rhs.viewportSubPixelBits ) - && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) - && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) - && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) - && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) - && ( minTexelOffset == rhs.minTexelOffset ) - && ( maxTexelOffset == rhs.maxTexelOffset ) - && ( minTexelGatherOffset == rhs.minTexelGatherOffset ) - && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) - && ( minInterpolationOffset == rhs.minInterpolationOffset ) - && ( maxInterpolationOffset == rhs.maxInterpolationOffset ) - && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) - && ( maxFramebufferWidth == rhs.maxFramebufferWidth ) - && ( maxFramebufferHeight == rhs.maxFramebufferHeight ) - && ( maxFramebufferLayers == rhs.maxFramebufferLayers ) - && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) - && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) - && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) - && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) - && ( maxColorAttachments == rhs.maxColorAttachments ) - && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) - && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) - && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) - && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) - && ( storageImageSampleCounts == rhs.storageImageSampleCounts ) - && ( maxSampleMaskWords == rhs.maxSampleMaskWords ) - && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) - && ( timestampPeriod == rhs.timestampPeriod ) - && ( maxClipDistances == rhs.maxClipDistances ) - && ( maxCullDistances == rhs.maxCullDistances ) - && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) - && ( discreteQueuePriorities == rhs.discreteQueuePriorities ) - && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 ) - && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 ) - && ( pointSizeGranularity == rhs.pointSizeGranularity ) - && ( lineWidthGranularity == rhs.lineWidthGranularity ) - && ( strictLines == rhs.strictLines ) - && ( standardSampleLocations == rhs.standardSampleLocations ) - && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) - && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) - && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); - } - - bool operator!=( PhysicalDeviceLimits const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - DeviceSize bufferImageGranularity; - DeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - DeviceSize minTexelBufferOffsetAlignment; - DeviceSize minUniformBufferOffsetAlignment; - DeviceSize minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - SampleCountFlags framebufferColorSampleCounts; - SampleCountFlags framebufferDepthSampleCounts; - SampleCountFlags framebufferStencilSampleCounts; - SampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - SampleCountFlags sampledImageColorSampleCounts; - SampleCountFlags sampledImageIntegerSampleCounts; - SampleCountFlags sampledImageDepthSampleCounts; - SampleCountFlags sampledImageStencilSampleCounts; - SampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - Bool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - Bool32 strictLines; - Bool32 standardSampleLocations; - DeviceSize optimalBufferCopyOffsetAlignment; - DeviceSize optimalBufferCopyRowPitchAlignment; - DeviceSize nonCoherentAtomSize; - }; - static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceProperties - { - operator const VkPhysicalDeviceProperties&() const - { - return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this); - } - - bool operator==( PhysicalDeviceProperties const& rhs ) const - { - return ( apiVersion == rhs.apiVersion ) - && ( driverVersion == rhs.driverVersion ) - && ( vendorID == rhs.vendorID ) - && ( deviceID == rhs.deviceID ) - && ( deviceType == rhs.deviceType ) - && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 ) - && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( limits == rhs.limits ) - && ( sparseProperties == rhs.sparseProperties ); - } - - bool operator!=( PhysicalDeviceProperties const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - PhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - PhysicalDeviceLimits limits; - PhysicalDeviceSparseProperties sparseProperties; - }; - static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceProperties2KHR - { - operator const VkPhysicalDeviceProperties2KHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceProperties2KHR*>(this); - } - - bool operator==( PhysicalDeviceProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( properties == rhs.properties ); - } - - bool operator!=( PhysicalDeviceProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceProperties2KHR; - - public: - void* pNext = nullptr; - PhysicalDeviceProperties properties; - }; - static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" ); - - struct ImageFormatProperties2KHR - { - operator const VkImageFormatProperties2KHR&() const - { - return *reinterpret_cast<const VkImageFormatProperties2KHR*>(this); - } - - bool operator==( ImageFormatProperties2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( imageFormatProperties == rhs.imageFormatProperties ); - } - - bool operator!=( ImageFormatProperties2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImageFormatProperties2KHR; - - public: - void* pNext = nullptr; - ImageFormatProperties imageFormatProperties; - }; - static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSparseImageFormatInfo2KHR - { - PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal ) - : format( format_ ) - , type( type_ ) - , samples( samples_ ) - , usage( usage_ ) - , tiling( tiling_ ) - { - } - - PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); - } - - PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); - return *this; - } - PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2KHR& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2KHR& setType( ImageType type_ ) - { - type = type_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2KHR& setSamples( SampleCountFlagBits samples_ ) - { - samples = samples_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - PhysicalDeviceSparseImageFormatInfo2KHR& setTiling( ImageTiling tiling_ ) - { - tiling = tiling_; - return *this; - } - - operator const VkPhysicalDeviceSparseImageFormatInfo2KHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>(this); - } - - bool operator==( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( type == rhs.type ) - && ( samples == rhs.samples ) - && ( usage == rhs.usage ) - && ( tiling == rhs.tiling ); - } - - bool operator!=( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR; - - public: - const void* pNext = nullptr; - Format format; - ImageType type; - SampleCountFlagBits samples; - ImageUsageFlags usage; - ImageTiling tiling; - }; - static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2KHR ), "struct and wrapper have different size!" ); - - struct SampleLocationsInfoEXT - { - SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, Extent2D sampleLocationGridSize_ = Extent2D(), uint32_t sampleLocationsCount_ = 0, const SampleLocationEXT* pSampleLocations_ = nullptr ) - : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) - , sampleLocationGridSize( sampleLocationGridSize_ ) - , sampleLocationsCount( sampleLocationsCount_ ) - , pSampleLocations( pSampleLocations_ ) - { - } - - SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) ); - } - - SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) ); - return *this; - } - SampleLocationsInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SampleLocationsInfoEXT& setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) - { - sampleLocationsPerPixel = sampleLocationsPerPixel_; - return *this; - } - - SampleLocationsInfoEXT& setSampleLocationGridSize( Extent2D sampleLocationGridSize_ ) - { - sampleLocationGridSize = sampleLocationGridSize_; - return *this; - } - - SampleLocationsInfoEXT& setSampleLocationsCount( uint32_t sampleLocationsCount_ ) - { - sampleLocationsCount = sampleLocationsCount_; - return *this; - } - - SampleLocationsInfoEXT& setPSampleLocations( const SampleLocationEXT* pSampleLocations_ ) - { - pSampleLocations = pSampleLocations_; - return *this; - } - - operator const VkSampleLocationsInfoEXT&() const - { - return *reinterpret_cast<const VkSampleLocationsInfoEXT*>(this); - } - - bool operator==( SampleLocationsInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) - && ( sampleLocationGridSize == rhs.sampleLocationGridSize ) - && ( sampleLocationsCount == rhs.sampleLocationsCount ) - && ( pSampleLocations == rhs.pSampleLocations ); - } - - bool operator!=( SampleLocationsInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSampleLocationsInfoEXT; - - public: - const void* pNext = nullptr; - SampleCountFlagBits sampleLocationsPerPixel; - Extent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const SampleLocationEXT* pSampleLocations; - }; - static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" ); - - struct AttachmentSampleLocationsEXT - { - AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) - : attachmentIndex( attachmentIndex_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - { - } - - AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) ); - } - - AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) ); - return *this; - } - AttachmentSampleLocationsEXT& setAttachmentIndex( uint32_t attachmentIndex_ ) - { - attachmentIndex = attachmentIndex_; - return *this; - } - - AttachmentSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - operator const VkAttachmentSampleLocationsEXT&() const - { - return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>(this); - } - - bool operator==( AttachmentSampleLocationsEXT const& rhs ) const - { - return ( attachmentIndex == rhs.attachmentIndex ) - && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); - } - - bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t attachmentIndex; - SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" ); - - struct SubpassSampleLocationsEXT - { - SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) - : subpassIndex( subpassIndex_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - { - } - - SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) ); - } - - SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) ); - return *this; - } - SubpassSampleLocationsEXT& setSubpassIndex( uint32_t subpassIndex_ ) - { - subpassIndex = subpassIndex_; - return *this; - } - - SubpassSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - operator const VkSubpassSampleLocationsEXT&() const - { - return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>(this); - } - - bool operator==( SubpassSampleLocationsEXT const& rhs ) const - { - return ( subpassIndex == rhs.subpassIndex ) - && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); - } - - bool operator!=( SubpassSampleLocationsEXT const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t subpassIndex; - SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" ); - - struct RenderPassSampleLocationsBeginInfoEXT - { - RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, uint32_t postSubpassSampleLocationsCount_ = 0, const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) - : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) - , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) - , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) - , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) - { - } - - RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) ); - } - - RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) ); - return *this; - } - RenderPassSampleLocationsBeginInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) - { - attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ ) - { - pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) - { - postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_; - return *this; - } - - RenderPassSampleLocationsBeginInfoEXT& setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ ) - { - pPostSubpassSampleLocations = pPostSubpassSampleLocations_; - return *this; - } - - operator const VkRenderPassSampleLocationsBeginInfoEXT&() const - { - return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(this); - } - - bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) - && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) - && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) - && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); - } - - bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; - - public: - const void* pNext = nullptr; - uint32_t attachmentInitialSampleLocationsCount; - const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const SubpassSampleLocationsEXT* pPostSubpassSampleLocations; - }; - static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" ); - - struct PipelineSampleLocationsStateCreateInfoEXT - { - PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() ) - : sampleLocationsEnable( sampleLocationsEnable_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - { - } - - PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) ); - } - - PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) ); - return *this; - } - PipelineSampleLocationsStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsEnable( Bool32 sampleLocationsEnable_ ) - { - sampleLocationsEnable = sampleLocationsEnable_; - return *this; - } - - PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ ) - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - operator const VkPipelineSampleLocationsStateCreateInfoEXT&() const - { - return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(this); - } - - bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sampleLocationsEnable == rhs.sampleLocationsEnable ) - && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); - } - - bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - Bool32 sampleLocationsEnable; - SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceSampleLocationsPropertiesEXT - { - operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const - { - return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this); - } - - bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) - && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) - && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 ) - && ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) - && ( variableSampleLocations == rhs.variableSampleLocations ); - } - - bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; - - public: - void* pNext = nullptr; - SampleCountFlags sampleLocationSampleCounts; - Extent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - Bool32 variableSampleLocations; - }; - static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" ); - - enum class AttachmentDescriptionFlagBits - { - eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT - }; - - using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>; - - VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 ) - { - return AttachmentDescriptionFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits ) - { - return ~( AttachmentDescriptionFlags( bits ) ); - } - - template <> struct FlagTraits<AttachmentDescriptionFlagBits> - { - enum - { - allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias) - }; - }; - - struct AttachmentDescription - { - 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 ) - : flags( flags_ ) - , format( format_ ) - , samples( samples_ ) - , loadOp( loadOp_ ) - , storeOp( storeOp_ ) - , stencilLoadOp( stencilLoadOp_ ) - , stencilStoreOp( stencilStoreOp_ ) - , initialLayout( initialLayout_ ) - , finalLayout( finalLayout_ ) - { - } - - AttachmentDescription( VkAttachmentDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentDescription ) ); - } - - AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( AttachmentDescription ) ); - return *this; - } - AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ ) - { - flags = flags_; - return *this; - } - - AttachmentDescription& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - AttachmentDescription& setSamples( SampleCountFlagBits samples_ ) - { - samples = samples_; - return *this; - } - - AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ ) - { - loadOp = loadOp_; - return *this; - } - - AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ ) - { - storeOp = storeOp_; - return *this; - } - - AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) - { - stencilLoadOp = stencilLoadOp_; - return *this; - } - - AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) - { - stencilStoreOp = stencilStoreOp_; - return *this; - } - - AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ ) - { - initialLayout = initialLayout_; - return *this; - } - - AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ ) - { - finalLayout = finalLayout_; - return *this; - } - - operator const VkAttachmentDescription&() const - { - return *reinterpret_cast<const VkAttachmentDescription*>(this); - } - - bool operator==( AttachmentDescription const& rhs ) const - { - return ( flags == rhs.flags ) - && ( format == rhs.format ) - && ( samples == rhs.samples ) - && ( loadOp == rhs.loadOp ) - && ( storeOp == rhs.storeOp ) - && ( stencilLoadOp == rhs.stencilLoadOp ) - && ( stencilStoreOp == rhs.stencilStoreOp ) - && ( initialLayout == rhs.initialLayout ) - && ( finalLayout == rhs.finalLayout ); - } - - bool operator!=( AttachmentDescription const& rhs ) const - { - return !operator==( rhs ); - } - - AttachmentDescriptionFlags flags; - Format format; - SampleCountFlagBits samples; - AttachmentLoadOp loadOp; - AttachmentStoreOp storeOp; - AttachmentLoadOp stencilLoadOp; - AttachmentStoreOp stencilStoreOp; - ImageLayout initialLayout; - ImageLayout finalLayout; - }; - static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); - - enum class StencilFaceFlagBits - { - eFront = VK_STENCIL_FACE_FRONT_BIT, - eBack = VK_STENCIL_FACE_BACK_BIT, - eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK - }; - - using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>; - - VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 ) - { - return StencilFaceFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits ) - { - return ~( StencilFaceFlags( bits ) ); - } - - template <> struct FlagTraits<StencilFaceFlagBits> - { - enum - { - allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack) - }; - }; - - enum class DescriptorPoolCreateFlagBits - { - eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT - }; - - using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>; - - VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 ) - { - return DescriptorPoolCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits ) - { - return ~( DescriptorPoolCreateFlags( bits ) ); - } - - template <> struct FlagTraits<DescriptorPoolCreateFlagBits> - { - enum - { - allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet) - }; - }; - - struct DescriptorPoolCreateInfo - { - DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr ) - : flags( flags_ ) - , maxSets( maxSets_ ) - , poolSizeCount( poolSizeCount_ ) - , pPoolSizes( pPoolSizes_ ) - { - } - - DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); - } - - DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); - return *this; - } - DescriptorPoolCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ ) - { - maxSets = maxSets_; - return *this; - } - - DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ ) - { - poolSizeCount = poolSizeCount_; - return *this; - } - - DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ ) - { - pPoolSizes = pPoolSizes_; - return *this; - } - - operator const VkDescriptorPoolCreateInfo&() const - { - return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this); - } - - bool operator==( DescriptorPoolCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( maxSets == rhs.maxSets ) - && ( poolSizeCount == rhs.poolSizeCount ) - && ( pPoolSizes == rhs.pPoolSizes ); - } - - bool operator!=( DescriptorPoolCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorPoolCreateInfo; - - public: - const void* pNext = nullptr; - DescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const DescriptorPoolSize* pPoolSizes; - }; - static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); - - enum class DependencyFlagBits - { - eByRegion = VK_DEPENDENCY_BY_REGION_BIT, - eViewLocalKHX = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX, - eDeviceGroupKHX = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX - }; - - using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>; - - VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 ) - { - return DependencyFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits ) - { - return ~( DependencyFlags( bits ) ); - } - - template <> struct FlagTraits<DependencyFlagBits> - { - enum - { - allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eViewLocalKHX) | VkFlags(DependencyFlagBits::eDeviceGroupKHX) - }; - }; - - struct SubpassDependency - { - SubpassDependency( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, PipelineStageFlags srcStageMask_ = PipelineStageFlags(), PipelineStageFlags dstStageMask_ = PipelineStageFlags(), AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), DependencyFlags dependencyFlags_ = DependencyFlags() ) - : srcSubpass( srcSubpass_ ) - , dstSubpass( dstSubpass_ ) - , srcStageMask( srcStageMask_ ) - , dstStageMask( dstStageMask_ ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , dependencyFlags( dependencyFlags_ ) - { - } - - SubpassDependency( VkSubpassDependency const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDependency ) ); - } - - SubpassDependency& operator=( VkSubpassDependency const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDependency ) ); - return *this; - } - SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ ) - { - srcSubpass = srcSubpass_; - return *this; - } - - SubpassDependency& setDstSubpass( uint32_t dstSubpass_ ) - { - dstSubpass = dstSubpass_; - return *this; - } - - SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ ) - { - srcStageMask = srcStageMask_; - return *this; - } - - SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ ) - { - dstStageMask = dstStageMask_; - return *this; - } - - SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ ) - { - srcAccessMask = srcAccessMask_; - return *this; - } - - SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ ) - { - dstAccessMask = dstAccessMask_; - return *this; - } - - SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ ) - { - dependencyFlags = dependencyFlags_; - return *this; - } - - operator const VkSubpassDependency&() const - { - return *reinterpret_cast<const VkSubpassDependency*>(this); - } - - bool operator==( SubpassDependency const& rhs ) const - { - return ( srcSubpass == rhs.srcSubpass ) - && ( dstSubpass == rhs.dstSubpass ) - && ( srcStageMask == rhs.srcStageMask ) - && ( dstStageMask == rhs.dstStageMask ) - && ( srcAccessMask == rhs.srcAccessMask ) - && ( dstAccessMask == rhs.dstAccessMask ) - && ( dependencyFlags == rhs.dependencyFlags ); - } - - bool operator!=( SubpassDependency const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t srcSubpass; - uint32_t dstSubpass; - PipelineStageFlags srcStageMask; - PipelineStageFlags dstStageMask; - AccessFlags srcAccessMask; - AccessFlags dstAccessMask; - DependencyFlags dependencyFlags; - }; - static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); - - enum class PresentModeKHR - { - eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, - eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, - eFifo = VK_PRESENT_MODE_FIFO_KHR, - eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, - eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, - eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR - }; - - enum class ColorSpaceKHR - { - eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, - eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, - eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, - eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, - eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, - eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, - eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, - eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, - eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT, - eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, - eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, - eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, - ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, - eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT - }; - - struct SurfaceFormatKHR - { - operator const VkSurfaceFormatKHR&() const - { - return *reinterpret_cast<const VkSurfaceFormatKHR*>(this); - } - - bool operator==( SurfaceFormatKHR const& rhs ) const - { - return ( format == rhs.format ) - && ( colorSpace == rhs.colorSpace ); - } - - bool operator!=( SurfaceFormatKHR const& rhs ) const - { - return !operator==( rhs ); - } - - Format format; - ColorSpaceKHR colorSpace; - }; - static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); - - struct SurfaceFormat2KHR - { - operator const VkSurfaceFormat2KHR&() const - { - return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this); - } - - bool operator==( SurfaceFormat2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surfaceFormat == rhs.surfaceFormat ); - } - - bool operator!=( SurfaceFormat2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSurfaceFormat2KHR; - - public: - void* pNext = nullptr; - SurfaceFormatKHR surfaceFormat; - }; - static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); - - enum class DisplayPlaneAlphaFlagBitsKHR - { - eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, - eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, - ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, - ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR - }; - - using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>; - - VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 ) - { - return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits ) - { - return ~( DisplayPlaneAlphaFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR> - { - enum - { - allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) - }; - }; - - struct DisplayPlaneCapabilitiesKHR - { - operator const VkDisplayPlaneCapabilitiesKHR&() const - { - return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this); - } - - bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const - { - return ( supportedAlpha == rhs.supportedAlpha ) - && ( minSrcPosition == rhs.minSrcPosition ) - && ( maxSrcPosition == rhs.maxSrcPosition ) - && ( minSrcExtent == rhs.minSrcExtent ) - && ( maxSrcExtent == rhs.maxSrcExtent ) - && ( minDstPosition == rhs.minDstPosition ) - && ( maxDstPosition == rhs.maxDstPosition ) - && ( minDstExtent == rhs.minDstExtent ) - && ( maxDstExtent == rhs.maxDstExtent ); - } - - bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayPlaneAlphaFlagsKHR supportedAlpha; - Offset2D minSrcPosition; - Offset2D maxSrcPosition; - Extent2D minSrcExtent; - Extent2D maxSrcExtent; - Offset2D minDstPosition; - Offset2D maxDstPosition; - Extent2D minDstExtent; - Extent2D maxDstExtent; - }; - static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); - - enum class CompositeAlphaFlagBitsKHR - { - eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, - ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, - ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, - eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR - }; - - using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>; - - VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 ) - { - return CompositeAlphaFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits ) - { - return ~( CompositeAlphaFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<CompositeAlphaFlagBitsKHR> - { - enum - { - allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit) - }; - }; - - enum class SurfaceTransformFlagBitsKHR - { - eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, - eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, - eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, - eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, - eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, - eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, - eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, - eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, - eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR - }; - - using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>; - - VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 ) - { - return SurfaceTransformFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits ) - { - return ~( SurfaceTransformFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<SurfaceTransformFlagBitsKHR> - { - enum - { - allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit) - }; - }; - - struct DisplayPropertiesKHR - { - operator const VkDisplayPropertiesKHR&() const - { - return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this); - } - - bool operator==( DisplayPropertiesKHR const& rhs ) const - { - return ( display == rhs.display ) - && ( displayName == rhs.displayName ) - && ( physicalDimensions == rhs.physicalDimensions ) - && ( physicalResolution == rhs.physicalResolution ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( planeReorderPossible == rhs.planeReorderPossible ) - && ( persistentContent == rhs.persistentContent ); - } - - bool operator!=( DisplayPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - DisplayKHR display; - const char* displayName; - Extent2D physicalDimensions; - Extent2D physicalResolution; - SurfaceTransformFlagsKHR supportedTransforms; - Bool32 planeReorderPossible; - Bool32 persistentContent; - }; - static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); - - struct DisplaySurfaceCreateInfoKHR - { - 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() ) - : flags( flags_ ) - , displayMode( displayMode_ ) - , planeIndex( planeIndex_ ) - , planeStackIndex( planeStackIndex_ ) - , transform( transform_ ) - , globalAlpha( globalAlpha_ ) - , alphaMode( alphaMode_ ) - , imageExtent( imageExtent_ ) - { - } - - DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); - } - - DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); - return *this; - } - DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ ) - { - displayMode = displayMode_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ ) - { - planeIndex = planeIndex_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ ) - { - planeStackIndex = planeStackIndex_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ ) - { - transform = transform_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ ) - { - globalAlpha = globalAlpha_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) - { - alphaMode = alphaMode_; - return *this; - } - - DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) - { - imageExtent = imageExtent_; - return *this; - } - - operator const VkDisplaySurfaceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this); - } - - bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( displayMode == rhs.displayMode ) - && ( planeIndex == rhs.planeIndex ) - && ( planeStackIndex == rhs.planeStackIndex ) - && ( transform == rhs.transform ) - && ( globalAlpha == rhs.globalAlpha ) - && ( alphaMode == rhs.alphaMode ) - && ( imageExtent == rhs.imageExtent ); - } - - bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; - - public: - const void* pNext = nullptr; - DisplaySurfaceCreateFlagsKHR flags; - DisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - SurfaceTransformFlagBitsKHR transform; - float globalAlpha; - DisplayPlaneAlphaFlagBitsKHR alphaMode; - Extent2D imageExtent; - }; - static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct SurfaceCapabilitiesKHR - { - operator const VkSurfaceCapabilitiesKHR&() const - { - return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this); - } - - bool operator==( SurfaceCapabilitiesKHR const& rhs ) const - { - return ( minImageCount == rhs.minImageCount ) - && ( maxImageCount == rhs.maxImageCount ) - && ( currentExtent == rhs.currentExtent ) - && ( minImageExtent == rhs.minImageExtent ) - && ( maxImageExtent == rhs.maxImageExtent ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( currentTransform == rhs.currentTransform ) - && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) - && ( supportedUsageFlags == rhs.supportedUsageFlags ); - } - - bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - uint32_t minImageCount; - uint32_t maxImageCount; - Extent2D currentExtent; - Extent2D minImageExtent; - Extent2D maxImageExtent; - uint32_t maxImageArrayLayers; - SurfaceTransformFlagsKHR supportedTransforms; - SurfaceTransformFlagBitsKHR currentTransform; - CompositeAlphaFlagsKHR supportedCompositeAlpha; - ImageUsageFlags supportedUsageFlags; - }; - static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); - - struct SurfaceCapabilities2KHR - { - operator const VkSurfaceCapabilities2KHR&() const - { - return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this); - } - - bool operator==( SurfaceCapabilities2KHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surfaceCapabilities == rhs.surfaceCapabilities ); - } - - bool operator!=( SurfaceCapabilities2KHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSurfaceCapabilities2KHR; - - public: - void* pNext = nullptr; - SurfaceCapabilitiesKHR surfaceCapabilities; - }; - static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); - - enum class DebugReportFlagBitsEXT - { - eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, - eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT, - ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - eError = VK_DEBUG_REPORT_ERROR_BIT_EXT, - eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT - }; - - using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>; - - VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 ) - { - return DebugReportFlagsEXT( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits ) - { - return ~( DebugReportFlagsEXT( bits ) ); - } - - template <> struct FlagTraits<DebugReportFlagBitsEXT> - { - enum - { - allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug) - }; - }; - - struct DebugReportCallbackCreateInfoEXT - { - DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr ) - : flags( flags_ ) - , pfnCallback( pfnCallback_ ) - , pUserData( pUserData_ ) - { - } - - DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); - } - - DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); - return *this; - } - DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) - { - pfnCallback = pfnCallback_; - return *this; - } - - DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ ) - { - pUserData = pUserData_; - return *this; - } - - operator const VkDebugReportCallbackCreateInfoEXT&() const - { - return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this); - } - - bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( pfnCallback == rhs.pfnCallback ) - && ( pUserData == rhs.pUserData ); - } - - bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; - - public: - const void* pNext = nullptr; - DebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; - }; - static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class DebugReportObjectTypeEXT - { - eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, - eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, - eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, - eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, - eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, - ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, - ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, - eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, - eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, - eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, - eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, - eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, - eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, - eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, - eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, - eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, - eValidationCacheExt = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, - eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, - eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT - }; - - struct DebugMarkerObjectNameInfoEXT - { - DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr ) - : objectType( objectType_ ) - , object( object_ ) - , pObjectName( pObjectName_ ) - { - } - - DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); - } - - DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); - return *this; - } - DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) - { - objectType = objectType_; - return *this; - } - - DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ ) - { - object = object_; - return *this; - } - - DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ ) - { - pObjectName = pObjectName_; - return *this; - } - - operator const VkDebugMarkerObjectNameInfoEXT&() const - { - return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this); - } - - bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( object == rhs.object ) - && ( pObjectName == rhs.pObjectName ); - } - - bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; - - public: - const void* pNext = nullptr; - DebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; - }; - static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); - - struct DebugMarkerObjectTagInfoEXT - { - DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) - : objectType( objectType_ ) - , object( object_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - { - } - - DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); - } - - DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); - return *this; - } - DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ ) - { - objectType = objectType_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ ) - { - object = object_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ ) - { - tagName = tagName_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ ) - { - tagSize = tagSize_; - return *this; - } - - DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ ) - { - pTag = pTag_; - return *this; - } - - operator const VkDebugMarkerObjectTagInfoEXT&() const - { - return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this); - } - - bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectType == rhs.objectType ) - && ( object == rhs.object ) - && ( tagName == rhs.tagName ) - && ( tagSize == rhs.tagSize ) - && ( pTag == rhs.pTag ); - } - - bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; - - public: - const void* pNext = nullptr; - DebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); - - enum class RasterizationOrderAMD - { - eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, - eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD - }; - - struct PipelineRasterizationStateRasterizationOrderAMD - { - PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict ) - : rasterizationOrder( rasterizationOrder_ ) - { - } - - PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); - } - - PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); - return *this; - } - PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) - { - rasterizationOrder = rasterizationOrder_; - return *this; - } - - operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const - { - return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this); - } - - bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( rasterizationOrder == rhs.rasterizationOrder ); - } - - bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; - - public: - const void* pNext = nullptr; - RasterizationOrderAMD rasterizationOrder; - }; - static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); - - enum class ExternalMemoryHandleTypeFlagBitsNV - { - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, - eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, - eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV - }; - - using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>; - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 ) - { - return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits ) - { - return ~( ExternalMemoryHandleTypeFlagsNV( bits ) ); - } - - template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV> - { - enum - { - allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) - }; - }; - - struct ExternalMemoryImageCreateInfoNV - { - ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : handleTypes( handleTypes_ ) - { - } - - ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); - } - - ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); - return *this; - } - ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExternalMemoryImageCreateInfoNV&() const - { - return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this); - } - - bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); - - struct ExportMemoryAllocateInfoNV - { - ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() ) - : handleTypes( handleTypes_ ) - { - } - - ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); - } - - ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); - return *this; - } - ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportMemoryAllocateInfoNV&() const - { - return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this); - } - - bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryAllocateInfoNV; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportMemoryWin32HandleInfoNV - { - ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 ) - : handleType( handleType_ ) - , handle( handle_ ) - { - } - - ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); - } - - ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); - return *this; - } - ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - operator const VkImportMemoryWin32HandleInfoNV&() const - { - return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this); - } - - bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ); - } - - bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsNV handleType; - HANDLE handle; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - enum class ExternalMemoryFeatureFlagBitsNV - { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV - }; - - using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>; - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 ) - { - return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits ) - { - return ~( ExternalMemoryFeatureFlagsNV( bits ) ); - } - - template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV> - { - enum - { - allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable) - }; - }; - - struct ExternalImageFormatPropertiesNV - { - operator const VkExternalImageFormatPropertiesNV&() const - { - return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this); - } - - bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const - { - return ( imageFormatProperties == rhs.imageFormatProperties ) - && ( externalMemoryFeatures == rhs.externalMemoryFeatures ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); - } - - bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const - { - return !operator==( rhs ); - } - - ImageFormatProperties imageFormatProperties; - ExternalMemoryFeatureFlagsNV externalMemoryFeatures; - ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; - ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; - }; - static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); - - enum class ValidationCheckEXT - { - eAll = VK_VALIDATION_CHECK_ALL_EXT, - eShaders = VK_VALIDATION_CHECK_SHADERS_EXT - }; - - struct ValidationFlagsEXT - { - ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) - : disabledValidationCheckCount( disabledValidationCheckCount_ ) - , pDisabledValidationChecks( pDisabledValidationChecks_ ) - { - } - - ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); - } - - ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); - return *this; - } - ValidationFlagsEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) - { - disabledValidationCheckCount = disabledValidationCheckCount_; - return *this; - } - - ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ ) - { - pDisabledValidationChecks = pDisabledValidationChecks_; - return *this; - } - - operator const VkValidationFlagsEXT&() const - { - return *reinterpret_cast<const VkValidationFlagsEXT*>(this); - } - - bool operator==( ValidationFlagsEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) - && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); - } - - bool operator!=( ValidationFlagsEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eValidationFlagsEXT; - - public: - const void* pNext = nullptr; - uint32_t disabledValidationCheckCount; - ValidationCheckEXT* pDisabledValidationChecks; - }; - static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); - - enum class IndirectCommandsLayoutUsageFlagBitsNVX - { - eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX, - eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX, - eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX, - eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX - }; - - using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>; - - VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 ) - { - return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits ) - { - return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) ); - } - - template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX> - { - enum - { - allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) - }; - }; - - enum class ObjectEntryUsageFlagBitsNVX - { - eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX, - eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX - }; - - using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>; - - VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 ) - { - return ObjectEntryUsageFlagsNVX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits ) - { - return ~( ObjectEntryUsageFlagsNVX( bits ) ); - } - - template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX> - { - enum - { - allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute) - }; - }; - - enum class IndirectCommandsTokenTypeNVX - { - ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, - eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, - eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, - eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, - ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, - eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, - eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, - eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - }; - - struct IndirectCommandsTokenNVX - { - IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 ) - : tokenType( tokenType_ ) - , buffer( buffer_ ) - , offset( offset_ ) - { - } - - IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); - } - - IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); - return *this; - } - IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) - { - tokenType = tokenType_; - return *this; - } - - IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ ) - { - offset = offset_; - return *this; - } - - operator const VkIndirectCommandsTokenNVX&() const - { - return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this); - } - - bool operator==( IndirectCommandsTokenNVX const& rhs ) const - { - return ( tokenType == rhs.tokenType ) - && ( buffer == rhs.buffer ) - && ( offset == rhs.offset ); - } - - bool operator!=( IndirectCommandsTokenNVX const& rhs ) const - { - return !operator==( rhs ); - } - - IndirectCommandsTokenTypeNVX tokenType; - Buffer buffer; - DeviceSize offset; - }; - static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" ); - - struct IndirectCommandsLayoutTokenNVX - { - IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 ) - : tokenType( tokenType_ ) - , bindingUnit( bindingUnit_ ) - , dynamicCount( dynamicCount_ ) - , divisor( divisor_ ) - { - } - - IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); - } - - IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); - return *this; - } - IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) - { - tokenType = tokenType_; - return *this; - } - - IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ ) - { - bindingUnit = bindingUnit_; - return *this; - } - - IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ ) - { - dynamicCount = dynamicCount_; - return *this; - } - - IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ ) - { - divisor = divisor_; - return *this; - } - - operator const VkIndirectCommandsLayoutTokenNVX&() const - { - return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this); - } - - bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const - { - return ( tokenType == rhs.tokenType ) - && ( bindingUnit == rhs.bindingUnit ) - && ( dynamicCount == rhs.dynamicCount ) - && ( divisor == rhs.divisor ); - } - - bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const - { - return !operator==( rhs ); - } - - IndirectCommandsTokenTypeNVX tokenType; - uint32_t bindingUnit; - uint32_t dynamicCount; - uint32_t divisor; - }; - static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" ); - - struct IndirectCommandsLayoutCreateInfoNVX - { - IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) - : pipelineBindPoint( pipelineBindPoint_ ) - , flags( flags_ ) - , tokenCount( tokenCount_ ) - , pTokens( pTokens_ ) - { - } - - IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); - } - - IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); - return *this; - } - IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ ) - { - tokenCount = tokenCount_; - return *this; - } - - IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ ) - { - pTokens = pTokens_; - return *this; - } - - operator const VkIndirectCommandsLayoutCreateInfoNVX&() const - { - return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this); - } - - bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( flags == rhs.flags ) - && ( tokenCount == rhs.tokenCount ) - && ( pTokens == rhs.pTokens ); - } - - bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; - - public: - const void* pNext = nullptr; - PipelineBindPoint pipelineBindPoint; - IndirectCommandsLayoutUsageFlagsNVX flags; - uint32_t tokenCount; - const IndirectCommandsLayoutTokenNVX* pTokens; - }; - static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); - - enum class ObjectEntryTypeNVX - { - eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, - ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, - eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, - eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, - ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - }; - - struct ObjectTableCreateInfoNVX - { - 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 ) - : objectCount( objectCount_ ) - , pObjectEntryTypes( pObjectEntryTypes_ ) - , pObjectEntryCounts( pObjectEntryCounts_ ) - , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) - , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) - , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) - , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) - , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) - , maxPipelineLayouts( maxPipelineLayouts_ ) - { - } - - ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); - } - - ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); - return *this; - } - ObjectTableCreateInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ ) - { - objectCount = objectCount_; - return *this; - } - - ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ ) - { - pObjectEntryTypes = pObjectEntryTypes_; - return *this; - } - - ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ ) - { - pObjectEntryCounts = pObjectEntryCounts_; - return *this; - } - - ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ ) - { - pObjectEntryUsageFlags = pObjectEntryUsageFlags_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ ) - { - maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ ) - { - maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ ) - { - maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ ) - { - maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_; - return *this; - } - - ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ ) - { - maxPipelineLayouts = maxPipelineLayouts_; - return *this; - } - - operator const VkObjectTableCreateInfoNVX&() const - { - return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this); - } - - bool operator==( ObjectTableCreateInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectCount == rhs.objectCount ) - && ( pObjectEntryTypes == rhs.pObjectEntryTypes ) - && ( pObjectEntryCounts == rhs.pObjectEntryCounts ) - && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags ) - && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor ) - && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor ) - && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor ) - && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor ) - && ( maxPipelineLayouts == rhs.maxPipelineLayouts ); - } - - bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eObjectTableCreateInfoNVX; - - public: - const void* pNext = nullptr; - uint32_t objectCount; - const ObjectEntryTypeNVX* pObjectEntryTypes; - const uint32_t* pObjectEntryCounts; - const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; - uint32_t maxUniformBuffersPerDescriptor; - uint32_t maxStorageBuffersPerDescriptor; - uint32_t maxStorageImagesPerDescriptor; - uint32_t maxSampledImagesPerDescriptor; - uint32_t maxPipelineLayouts; - }; - static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableEntryNVX - { - ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() ) - : type( type_ ) - , flags( flags_ ) - { - } - - ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); - } - - ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); - return *this; - } - ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - operator const VkObjectTableEntryNVX&() const - { - return *reinterpret_cast<const VkObjectTableEntryNVX*>(this); - } - - bool operator==( ObjectTableEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ); - } - - bool operator!=( ObjectTableEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - }; - static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTablePipelineEntryNVX - { - ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() ) - : type( type_ ) - , flags( flags_ ) - , pipeline( pipeline_ ) - { - } - - ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); - } - - ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); - return *this; - } - ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ ) - { - pipeline = pipeline_; - return *this; - } - - operator const VkObjectTablePipelineEntryNVX&() const - { - return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this); - } - - bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipeline == rhs.pipeline ); - } - - bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Pipeline pipeline; - }; - static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableDescriptorSetEntryNVX - { - ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() ) - : type( type_ ) - , flags( flags_ ) - , pipelineLayout( pipelineLayout_ ) - , descriptorSet( descriptorSet_ ) - { - } - - ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); - } - - ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); - return *this; - } - ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) - { - pipelineLayout = pipelineLayout_; - return *this; - } - - ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ ) - { - descriptorSet = descriptorSet_; - return *this; - } - - operator const VkObjectTableDescriptorSetEntryNVX&() const - { - return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this); - } - - bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( descriptorSet == rhs.descriptorSet ); - } - - bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - PipelineLayout pipelineLayout; - DescriptorSet descriptorSet; - }; - static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableVertexBufferEntryNVX - { - ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() ) - : type( type_ ) - , flags( flags_ ) - , buffer( buffer_ ) - { - } - - ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); - } - - ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); - return *this; - } - ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - operator const VkObjectTableVertexBufferEntryNVX&() const - { - return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this); - } - - bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ); - } - - bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Buffer buffer; - }; - static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTableIndexBufferEntryNVX - { - ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 ) - : type( type_ ) - , flags( flags_ ) - , buffer( buffer_ ) - , indexType( indexType_ ) - { - } - - ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); - } - - ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); - return *this; - } - ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ ) - { - buffer = buffer_; - return *this; - } - - ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ ) - { - indexType = indexType_; - return *this; - } - - operator const VkObjectTableIndexBufferEntryNVX&() const - { - return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this); - } - - bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( buffer == rhs.buffer ) - && ( indexType == rhs.indexType ); - } - - bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - Buffer buffer; - IndexType indexType; - }; - static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" ); - - struct ObjectTablePushConstantEntryNVX - { - ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() ) - : type( type_ ) - , flags( flags_ ) - , pipelineLayout( pipelineLayout_ ) - , stageFlags( stageFlags_ ) - { - } - - ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); - } - - ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); - return *this; - } - ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ ) - { - type = type_; - return *this; - } - - ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ ) - { - flags = flags_; - return *this; - } - - ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ ) - { - pipelineLayout = pipelineLayout_; - return *this; - } - - ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ ) - { - stageFlags = stageFlags_; - return *this; - } - - operator const VkObjectTablePushConstantEntryNVX&() const - { - return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this); - } - - bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const - { - return ( type == rhs.type ) - && ( flags == rhs.flags ) - && ( pipelineLayout == rhs.pipelineLayout ) - && ( stageFlags == rhs.stageFlags ); - } - - bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const - { - return !operator==( rhs ); - } - - ObjectEntryTypeNVX type; - ObjectEntryUsageFlagsNVX flags; - PipelineLayout pipelineLayout; - ShaderStageFlags stageFlags; - }; - static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" ); - - enum class DescriptorSetLayoutCreateFlagBits - { - ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR - }; - - using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>; - - VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 ) - { - return DescriptorSetLayoutCreateFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits ) - { - return ~( DescriptorSetLayoutCreateFlags( bits ) ); - } - - template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits> - { - enum - { - allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) - }; - }; - - struct DescriptorSetLayoutCreateInfo - { - DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr ) - : flags( flags_ ) - , bindingCount( bindingCount_ ) - , pBindings( pBindings_ ) - { - } - - DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); - } - - DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); - return *this; - } - DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ ) - { - bindingCount = bindingCount_; - return *this; - } - - DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ ) - { - pBindings = pBindings_; - return *this; - } - - operator const VkDescriptorSetLayoutCreateInfo&() const - { - return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this); - } - - bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( bindingCount == rhs.bindingCount ) - && ( pBindings == rhs.pBindings ); - } - - bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; - - public: - const void* pNext = nullptr; - DescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const DescriptorSetLayoutBinding* pBindings; - }; - static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); - - enum class ExternalMemoryHandleTypeFlagBitsKHR - { - eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, - eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, - eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, - eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, - eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR, - eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, - eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, - eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT - }; - - using ExternalMemoryHandleTypeFlagsKHR = Flags<ExternalMemoryHandleTypeFlagBitsKHR, VkExternalMemoryHandleTypeFlagsKHR>; - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator|( ExternalMemoryHandleTypeFlagBitsKHR bit0, ExternalMemoryHandleTypeFlagBitsKHR bit1 ) - { - return ExternalMemoryHandleTypeFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator~( ExternalMemoryHandleTypeFlagBitsKHR bits ) - { - return ~( ExternalMemoryHandleTypeFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsKHR> - { - enum - { - allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT) - }; - }; - - struct PhysicalDeviceExternalImageFormatInfoKHR - { - PhysicalDeviceExternalImageFormatInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : handleType( handleType_ ) - { - } - - PhysicalDeviceExternalImageFormatInfoKHR( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) ); - } - - PhysicalDeviceExternalImageFormatInfoKHR& operator=( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) ); - return *this; - } - PhysicalDeviceExternalImageFormatInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalImageFormatInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalImageFormatInfoKHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfoKHR*>(this); - } - - bool operator==( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHR ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceExternalBufferInfoKHR - { - PhysicalDeviceExternalBufferInfoKHR( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : flags( flags_ ) - , usage( usage_ ) - , handleType( handleType_ ) - { - } - - PhysicalDeviceExternalBufferInfoKHR( VkPhysicalDeviceExternalBufferInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) ); - } - - PhysicalDeviceExternalBufferInfoKHR& operator=( VkPhysicalDeviceExternalBufferInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) ); - return *this; - } - PhysicalDeviceExternalBufferInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalBufferInfoKHR& setFlags( BufferCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - PhysicalDeviceExternalBufferInfoKHR& setUsage( BufferUsageFlags usage_ ) - { - usage = usage_; - return *this; - } - - PhysicalDeviceExternalBufferInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalBufferInfoKHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHR*>(this); - } - - bool operator==( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( usage == rhs.usage ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfoKHR; - - public: - const void* pNext = nullptr; - BufferCreateFlags flags; - BufferUsageFlags usage; - ExternalMemoryHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalBufferInfoKHR ) == sizeof( VkPhysicalDeviceExternalBufferInfoKHR ), "struct and wrapper have different size!" ); - - struct ExternalMemoryImageCreateInfoKHR - { - ExternalMemoryImageCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) - : handleTypes( handleTypes_ ) - { - } - - ExternalMemoryImageCreateInfoKHR( VkExternalMemoryImageCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) ); - } - - ExternalMemoryImageCreateInfoKHR& operator=( VkExternalMemoryImageCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) ); - return *this; - } - ExternalMemoryImageCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExternalMemoryImageCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExternalMemoryImageCreateInfoKHR&() const - { - return *reinterpret_cast<const VkExternalMemoryImageCreateInfoKHR*>(this); - } - - bool operator==( ExternalMemoryImageCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExternalMemoryImageCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalMemoryImageCreateInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsKHR handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfoKHR ) == sizeof( VkExternalMemoryImageCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct ExternalMemoryBufferCreateInfoKHR - { - ExternalMemoryBufferCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) - : handleTypes( handleTypes_ ) - { - } - - ExternalMemoryBufferCreateInfoKHR( VkExternalMemoryBufferCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) ); - } - - ExternalMemoryBufferCreateInfoKHR& operator=( VkExternalMemoryBufferCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) ); - return *this; - } - ExternalMemoryBufferCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExternalMemoryBufferCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExternalMemoryBufferCreateInfoKHR&() const - { - return *reinterpret_cast<const VkExternalMemoryBufferCreateInfoKHR*>(this); - } - - bool operator==( ExternalMemoryBufferCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExternalMemoryBufferCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalMemoryBufferCreateInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsKHR handleTypes; - }; - static_assert( sizeof( ExternalMemoryBufferCreateInfoKHR ) == sizeof( VkExternalMemoryBufferCreateInfoKHR ), "struct and wrapper have different size!" ); - - struct ExportMemoryAllocateInfoKHR - { - ExportMemoryAllocateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) - : handleTypes( handleTypes_ ) - { - } - - ExportMemoryAllocateInfoKHR( VkExportMemoryAllocateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) ); - } - - ExportMemoryAllocateInfoKHR& operator=( VkExportMemoryAllocateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) ); - return *this; - } - ExportMemoryAllocateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportMemoryAllocateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportMemoryAllocateInfoKHR&() const - { - return *reinterpret_cast<const VkExportMemoryAllocateInfoKHR*>(this); - } - - bool operator==( ExportMemoryAllocateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportMemoryAllocateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportMemoryAllocateInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagsKHR handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfoKHR ) == sizeof( VkExportMemoryAllocateInfoKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportMemoryWin32HandleInfoKHR - { - ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) - : handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - { - } - - ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); - } - - ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); - return *this; - } - ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkImportMemoryWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(this); - } - - bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ) - && ( name == rhs.name ); - } - - bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBitsKHR handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct MemoryGetWin32HandleInfoKHR - { - MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : memory( memory_ ) - , handleType( handleType_ ) - { - } - - MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); - } - - MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); - return *this; - } - MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkMemoryGetWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(this); - } - - bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memory == rhs.memory ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - DeviceMemory memory; - ExternalMemoryHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct ImportMemoryFdInfoKHR - { - ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) - : handleType( handleType_ ) - , fd( fd_ ) - { - } - - ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); - } - - ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); - return *this; - } - ImportMemoryFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryFdInfoKHR& setFd( int fd_ ) - { - fd = fd_; - return *this; - } - - operator const VkImportMemoryFdInfoKHR&() const - { - return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(this); - } - - bool operator==( ImportMemoryFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( fd == rhs.fd ); - } - - bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryFdInfoKHR; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBitsKHR handleType; - int fd; - }; - static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); - - struct MemoryGetFdInfoKHR - { - MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) - : memory( memory_ ) - , handleType( handleType_ ) - { - } - - MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); - } - - MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); - return *this; - } - MemoryGetFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ ) - { - memory = memory_; - return *this; - } - - MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkMemoryGetFdInfoKHR&() const - { - return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(this); - } - - bool operator==( MemoryGetFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memory == rhs.memory ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( MemoryGetFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryGetFdInfoKHR; - - public: - const void* pNext = nullptr; - DeviceMemory memory; - ExternalMemoryHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); - - struct ImportMemoryHostPointerInfoEXT - { - ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, void* pHostPointer_ = nullptr ) - : handleType( handleType_ ) - , pHostPointer( pHostPointer_ ) - { - } - - ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) ); - } - - ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) ); - return *this; - } - ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ ) - { - pHostPointer = pHostPointer_; - return *this; - } - - operator const VkImportMemoryHostPointerInfoEXT&() const - { - return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this); - } - - bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ) - && ( pHostPointer == rhs.pHostPointer ); - } - - bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; - - public: - const void* pNext = nullptr; - ExternalMemoryHandleTypeFlagBitsKHR handleType; - void* pHostPointer; - }; - static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" ); - - enum class ExternalMemoryFeatureFlagBitsKHR - { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR - }; - - using ExternalMemoryFeatureFlagsKHR = Flags<ExternalMemoryFeatureFlagBitsKHR, VkExternalMemoryFeatureFlagsKHR>; - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator|( ExternalMemoryFeatureFlagBitsKHR bit0, ExternalMemoryFeatureFlagBitsKHR bit1 ) - { - return ExternalMemoryFeatureFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator~( ExternalMemoryFeatureFlagBitsKHR bits ) - { - return ~( ExternalMemoryFeatureFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsKHR> - { - enum - { - allFlags = VkFlags(ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eImportable) - }; - }; - - struct ExternalMemoryPropertiesKHR - { - operator const VkExternalMemoryPropertiesKHR&() const - { - return *reinterpret_cast<const VkExternalMemoryPropertiesKHR*>(this); - } - - bool operator==( ExternalMemoryPropertiesKHR const& rhs ) const - { - return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); - } - - bool operator!=( ExternalMemoryPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - ExternalMemoryFeatureFlagsKHR externalMemoryFeatures; - ExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; - ExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; - }; - static_assert( sizeof( ExternalMemoryPropertiesKHR ) == sizeof( VkExternalMemoryPropertiesKHR ), "struct and wrapper have different size!" ); - - struct ExternalImageFormatPropertiesKHR - { - operator const VkExternalImageFormatPropertiesKHR&() const - { - return *reinterpret_cast<const VkExternalImageFormatPropertiesKHR*>(this); - } - - bool operator==( ExternalImageFormatPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( externalMemoryProperties == rhs.externalMemoryProperties ); - } - - bool operator!=( ExternalImageFormatPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalImageFormatPropertiesKHR; - - public: - void* pNext = nullptr; - ExternalMemoryPropertiesKHR externalMemoryProperties; - }; - static_assert( sizeof( ExternalImageFormatPropertiesKHR ) == sizeof( VkExternalImageFormatPropertiesKHR ), "struct and wrapper have different size!" ); - - struct ExternalBufferPropertiesKHR - { - operator const VkExternalBufferPropertiesKHR&() const - { - return *reinterpret_cast<const VkExternalBufferPropertiesKHR*>(this); - } - - bool operator==( ExternalBufferPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( externalMemoryProperties == rhs.externalMemoryProperties ); - } - - bool operator!=( ExternalBufferPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalBufferPropertiesKHR; - - public: - void* pNext = nullptr; - ExternalMemoryPropertiesKHR externalMemoryProperties; - }; - static_assert( sizeof( ExternalBufferPropertiesKHR ) == sizeof( VkExternalBufferPropertiesKHR ), "struct and wrapper have different size!" ); - - enum class ExternalSemaphoreHandleTypeFlagBitsKHR - { - eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, - eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, - eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, - eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, - eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR - }; - - using ExternalSemaphoreHandleTypeFlagsKHR = Flags<ExternalSemaphoreHandleTypeFlagBitsKHR, VkExternalSemaphoreHandleTypeFlagsKHR>; - - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator|( ExternalSemaphoreHandleTypeFlagBitsKHR bit0, ExternalSemaphoreHandleTypeFlagBitsKHR bit1 ) - { - return ExternalSemaphoreHandleTypeFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator~( ExternalSemaphoreHandleTypeFlagBitsKHR bits ) - { - return ~( ExternalSemaphoreHandleTypeFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBitsKHR> - { - enum - { - allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd) - }; - }; - - struct PhysicalDeviceExternalSemaphoreInfoKHR - { - PhysicalDeviceExternalSemaphoreInfoKHR( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) - : handleType( handleType_ ) - { - } - - PhysicalDeviceExternalSemaphoreInfoKHR( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) ); - } - - PhysicalDeviceExternalSemaphoreInfoKHR& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) ); - return *this; - } - PhysicalDeviceExternalSemaphoreInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalSemaphoreInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalSemaphoreInfoKHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHR*>(this); - } - - bool operator==( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR; - - public: - const void* pNext = nullptr; - ExternalSemaphoreHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHR ), "struct and wrapper have different size!" ); - - struct ExportSemaphoreCreateInfoKHR - { - ExportSemaphoreCreateInfoKHR( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHR() ) - : handleTypes( handleTypes_ ) - { - } - - ExportSemaphoreCreateInfoKHR( VkExportSemaphoreCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) ); - } - - ExportSemaphoreCreateInfoKHR& operator=( VkExportSemaphoreCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) ); - return *this; - } - ExportSemaphoreCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportSemaphoreCreateInfoKHR& setHandleTypes( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportSemaphoreCreateInfoKHR&() const - { - return *reinterpret_cast<const VkExportSemaphoreCreateInfoKHR*>(this); - } - - bool operator==( ExportSemaphoreCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportSemaphoreCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportSemaphoreCreateInfoKHR; - - public: - const void* pNext = nullptr; - ExternalSemaphoreHandleTypeFlagsKHR handleTypes; - }; - static_assert( sizeof( ExportSemaphoreCreateInfoKHR ) == sizeof( VkExportSemaphoreCreateInfoKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct SemaphoreGetWin32HandleInfoKHR - { - SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) - : semaphore( semaphore_ ) - , handleType( handleType_ ) - { - } - - SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); - } - - SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); - return *this; - } - SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkSemaphoreGetWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(this); - } - - bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct SemaphoreGetFdInfoKHR - { - SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) - : semaphore( semaphore_ ) - , handleType( handleType_ ) - { - } - - SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); - } - - SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); - return *this; - } - SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkSemaphoreGetFdInfoKHR&() const - { - return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(this); - } - - bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class ExternalSemaphoreFeatureFlagBitsKHR - { - eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR, - eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR - }; - - using ExternalSemaphoreFeatureFlagsKHR = Flags<ExternalSemaphoreFeatureFlagBitsKHR, VkExternalSemaphoreFeatureFlagsKHR>; - - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator|( ExternalSemaphoreFeatureFlagBitsKHR bit0, ExternalSemaphoreFeatureFlagBitsKHR bit1 ) - { - return ExternalSemaphoreFeatureFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator~( ExternalSemaphoreFeatureFlagBitsKHR bits ) - { - return ~( ExternalSemaphoreFeatureFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBitsKHR> - { - enum - { - allFlags = VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eImportable) - }; - }; - - struct ExternalSemaphorePropertiesKHR - { - operator const VkExternalSemaphorePropertiesKHR&() const - { - return *reinterpret_cast<const VkExternalSemaphorePropertiesKHR*>(this); - } - - bool operator==( ExternalSemaphorePropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) - && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); - } - - bool operator!=( ExternalSemaphorePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalSemaphorePropertiesKHR; - - public: - void* pNext = nullptr; - ExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; - ExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; - ExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; - }; - static_assert( sizeof( ExternalSemaphorePropertiesKHR ) == sizeof( VkExternalSemaphorePropertiesKHR ), "struct and wrapper have different size!" ); - - enum class SemaphoreImportFlagBitsKHR - { - eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR - }; - - using SemaphoreImportFlagsKHR = Flags<SemaphoreImportFlagBitsKHR, VkSemaphoreImportFlagsKHR>; - - VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator|( SemaphoreImportFlagBitsKHR bit0, SemaphoreImportFlagBitsKHR bit1 ) - { - return SemaphoreImportFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator~( SemaphoreImportFlagBitsKHR bits ) - { - return ~( SemaphoreImportFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<SemaphoreImportFlagBitsKHR> - { - enum - { - allFlags = VkFlags(SemaphoreImportFlagBitsKHR::eTemporary) - }; - }; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportSemaphoreWin32HandleInfoKHR - { - ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - { - } - - ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); - } - - ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); - return *this; - } - ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkImportSemaphoreWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(this); - } - - bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ) - && ( name == rhs.name ); - } - - bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - SemaphoreImportFlagsKHR flags; - ExternalSemaphoreHandleTypeFlagBitsKHR handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct ImportSemaphoreFdInfoKHR - { - ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - { - } - - ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); - } - - ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); - return *this; - } - ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ ) - { - semaphore = semaphore_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportSemaphoreFdInfoKHR& setFd( int fd_ ) - { - fd = fd_; - return *this; - } - - operator const VkImportSemaphoreFdInfoKHR&() const - { - return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(this); - } - - bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( semaphore == rhs.semaphore ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( fd == rhs.fd ); - } - - bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; - - public: - const void* pNext = nullptr; - Semaphore semaphore; - SemaphoreImportFlagsKHR flags; - ExternalSemaphoreHandleTypeFlagBitsKHR handleType; - int fd; - }; - static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class ExternalFenceHandleTypeFlagBitsKHR - { - eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, - eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, - eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, - eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR - }; - - using ExternalFenceHandleTypeFlagsKHR = Flags<ExternalFenceHandleTypeFlagBitsKHR, VkExternalFenceHandleTypeFlagsKHR>; - - VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator|( ExternalFenceHandleTypeFlagBitsKHR bit0, ExternalFenceHandleTypeFlagBitsKHR bit1 ) - { - return ExternalFenceHandleTypeFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator~( ExternalFenceHandleTypeFlagBitsKHR bits ) - { - return ~( ExternalFenceHandleTypeFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<ExternalFenceHandleTypeFlagBitsKHR> - { - enum - { - allFlags = VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eSyncFd) - }; - }; - - struct PhysicalDeviceExternalFenceInfoKHR - { - PhysicalDeviceExternalFenceInfoKHR( ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) - : handleType( handleType_ ) - { - } - - PhysicalDeviceExternalFenceInfoKHR( VkPhysicalDeviceExternalFenceInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) ); - } - - PhysicalDeviceExternalFenceInfoKHR& operator=( VkPhysicalDeviceExternalFenceInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) ); - return *this; - } - PhysicalDeviceExternalFenceInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PhysicalDeviceExternalFenceInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkPhysicalDeviceExternalFenceInfoKHR&() const - { - return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfoKHR*>(this); - } - - bool operator==( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfoKHR; - - public: - const void* pNext = nullptr; - ExternalFenceHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalFenceInfoKHR ) == sizeof( VkPhysicalDeviceExternalFenceInfoKHR ), "struct and wrapper have different size!" ); - - struct ExportFenceCreateInfoKHR - { - ExportFenceCreateInfoKHR( ExternalFenceHandleTypeFlagsKHR handleTypes_ = ExternalFenceHandleTypeFlagsKHR() ) - : handleTypes( handleTypes_ ) - { - } - - ExportFenceCreateInfoKHR( VkExportFenceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) ); - } - - ExportFenceCreateInfoKHR& operator=( VkExportFenceCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) ); - return *this; - } - ExportFenceCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ExportFenceCreateInfoKHR& setHandleTypes( ExternalFenceHandleTypeFlagsKHR handleTypes_ ) - { - handleTypes = handleTypes_; - return *this; - } - - operator const VkExportFenceCreateInfoKHR&() const - { - return *reinterpret_cast<const VkExportFenceCreateInfoKHR*>(this); - } - - bool operator==( ExportFenceCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( handleTypes == rhs.handleTypes ); - } - - bool operator!=( ExportFenceCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExportFenceCreateInfoKHR; - - public: - const void* pNext = nullptr; - ExternalFenceHandleTypeFlagsKHR handleTypes; - }; - static_assert( sizeof( ExportFenceCreateInfoKHR ) == sizeof( VkExportFenceCreateInfoKHR ), "struct and wrapper have different size!" ); - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct FenceGetWin32HandleInfoKHR - { - FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) - : fence( fence_ ) - , handleType( handleType_ ) - { - } - - FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); - } - - FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); - return *this; - } - FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FenceGetWin32HandleInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkFenceGetWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(this); - } - - bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - ExternalFenceHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct FenceGetFdInfoKHR - { - FenceGetFdInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) - : fence( fence_ ) - , handleType( handleType_ ) - { - } - - FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); - } - - FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); - return *this; - } - FenceGetFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - FenceGetFdInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - operator const VkFenceGetFdInfoKHR&() const - { - return *reinterpret_cast<const VkFenceGetFdInfoKHR*>(this); - } - - bool operator==( FenceGetFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( handleType == rhs.handleType ); - } - - bool operator!=( FenceGetFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eFenceGetFdInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - ExternalFenceHandleTypeFlagBitsKHR handleType; - }; - static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class ExternalFenceFeatureFlagBitsKHR - { - eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR, - eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR - }; - - using ExternalFenceFeatureFlagsKHR = Flags<ExternalFenceFeatureFlagBitsKHR, VkExternalFenceFeatureFlagsKHR>; - - VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator|( ExternalFenceFeatureFlagBitsKHR bit0, ExternalFenceFeatureFlagBitsKHR bit1 ) - { - return ExternalFenceFeatureFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator~( ExternalFenceFeatureFlagBitsKHR bits ) - { - return ~( ExternalFenceFeatureFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<ExternalFenceFeatureFlagBitsKHR> - { - enum - { - allFlags = VkFlags(ExternalFenceFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalFenceFeatureFlagBitsKHR::eImportable) - }; - }; - - struct ExternalFencePropertiesKHR - { - operator const VkExternalFencePropertiesKHR&() const - { - return *reinterpret_cast<const VkExternalFencePropertiesKHR*>(this); - } - - bool operator==( ExternalFencePropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) - && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) - && ( externalFenceFeatures == rhs.externalFenceFeatures ); - } - - bool operator!=( ExternalFencePropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eExternalFencePropertiesKHR; - - public: - void* pNext = nullptr; - ExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; - ExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; - ExternalFenceFeatureFlagsKHR externalFenceFeatures; - }; - static_assert( sizeof( ExternalFencePropertiesKHR ) == sizeof( VkExternalFencePropertiesKHR ), "struct and wrapper have different size!" ); - - enum class FenceImportFlagBitsKHR - { - eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR - }; - - using FenceImportFlagsKHR = Flags<FenceImportFlagBitsKHR, VkFenceImportFlagsKHR>; - - VULKAN_HPP_INLINE FenceImportFlagsKHR operator|( FenceImportFlagBitsKHR bit0, FenceImportFlagBitsKHR bit1 ) - { - return FenceImportFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE FenceImportFlagsKHR operator~( FenceImportFlagBitsKHR bits ) - { - return ~( FenceImportFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<FenceImportFlagBitsKHR> - { - enum - { - allFlags = VkFlags(FenceImportFlagBitsKHR::eTemporary) - }; - }; - -#ifdef VK_USE_PLATFORM_WIN32_KHR - struct ImportFenceWin32HandleInfoKHR - { - ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - { - } - - ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); - } - - ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); - return *this; - } - ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ ) - { - handle = handle_; - return *this; - } - - ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) - { - name = name_; - return *this; - } - - operator const VkImportFenceWin32HandleInfoKHR&() const - { - return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(this); - } - - bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ) - && ( name == rhs.name ); - } - - bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - FenceImportFlagsKHR flags; - ExternalFenceHandleTypeFlagBitsKHR handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - struct ImportFenceFdInfoKHR - { - ImportFenceFdInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - { - } - - ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); - } - - ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); - return *this; - } - ImportFenceFdInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - ImportFenceFdInfoKHR& setFence( Fence fence_ ) - { - fence = fence_; - return *this; - } - - ImportFenceFdInfoKHR& setFlags( FenceImportFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) - { - handleType = handleType_; - return *this; - } - - ImportFenceFdInfoKHR& setFd( int fd_ ) - { - fd = fd_; - return *this; - } - - operator const VkImportFenceFdInfoKHR&() const - { - return *reinterpret_cast<const VkImportFenceFdInfoKHR*>(this); - } - - bool operator==( ImportFenceFdInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( fence == rhs.fence ) - && ( flags == rhs.flags ) - && ( handleType == rhs.handleType ) - && ( fd == rhs.fd ); - } - - bool operator!=( ImportFenceFdInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eImportFenceFdInfoKHR; - - public: - const void* pNext = nullptr; - Fence fence; - FenceImportFlagsKHR flags; - ExternalFenceHandleTypeFlagBitsKHR handleType; - int fd; - }; - static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); - - enum class SurfaceCounterFlagBitsEXT - { - eVblank = VK_SURFACE_COUNTER_VBLANK_EXT - }; - - using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>; - - VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 ) - { - return SurfaceCounterFlagsEXT( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits ) - { - return ~( SurfaceCounterFlagsEXT( bits ) ); - } - - template <> struct FlagTraits<SurfaceCounterFlagBitsEXT> - { - enum - { - allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank) - }; - }; - - struct SurfaceCapabilities2EXT - { - operator const VkSurfaceCapabilities2EXT&() const - { - return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this); - } - - bool operator==( SurfaceCapabilities2EXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( minImageCount == rhs.minImageCount ) - && ( maxImageCount == rhs.maxImageCount ) - && ( currentExtent == rhs.currentExtent ) - && ( minImageExtent == rhs.minImageExtent ) - && ( maxImageExtent == rhs.maxImageExtent ) - && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) - && ( supportedTransforms == rhs.supportedTransforms ) - && ( currentTransform == rhs.currentTransform ) - && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) - && ( supportedUsageFlags == rhs.supportedUsageFlags ) - && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters ); - } - - bool operator!=( SurfaceCapabilities2EXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSurfaceCapabilities2EXT; - - public: - void* pNext = nullptr; - uint32_t minImageCount; - uint32_t maxImageCount; - Extent2D currentExtent; - Extent2D minImageExtent; - Extent2D maxImageExtent; - uint32_t maxImageArrayLayers; - SurfaceTransformFlagsKHR supportedTransforms; - SurfaceTransformFlagBitsKHR currentTransform; - CompositeAlphaFlagsKHR supportedCompositeAlpha; - ImageUsageFlags supportedUsageFlags; - SurfaceCounterFlagsEXT supportedSurfaceCounters; - }; - static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" ); - - struct SwapchainCounterCreateInfoEXT - { - SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() ) - : surfaceCounters( surfaceCounters_ ) - { - } - - SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); - } - - SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); - return *this; - } - SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ ) - { - surfaceCounters = surfaceCounters_; - return *this; - } - - operator const VkSwapchainCounterCreateInfoEXT&() const - { - return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this); - } - - bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( surfaceCounters == rhs.surfaceCounters ); - } - - bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; - - public: - const void* pNext = nullptr; - SurfaceCounterFlagsEXT surfaceCounters; - }; - static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class DisplayPowerStateEXT - { - eOff = VK_DISPLAY_POWER_STATE_OFF_EXT, - eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT, - eOn = VK_DISPLAY_POWER_STATE_ON_EXT - }; - - struct DisplayPowerInfoEXT - { - DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff ) - : powerState( powerState_ ) - { - } - - DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); - } - - DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); - return *this; - } - DisplayPowerInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ ) - { - powerState = powerState_; - return *this; - } - - operator const VkDisplayPowerInfoEXT&() const - { - return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this); - } - - bool operator==( DisplayPowerInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( powerState == rhs.powerState ); - } - - bool operator!=( DisplayPowerInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayPowerInfoEXT; - - public: - const void* pNext = nullptr; - DisplayPowerStateEXT powerState; - }; - static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); - - enum class DeviceEventTypeEXT - { - eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - }; - - struct DeviceEventInfoEXT - { - DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug ) - : deviceEvent( deviceEvent_ ) - { - } - - DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); - } - - DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); - return *this; - } - DeviceEventInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ ) - { - deviceEvent = deviceEvent_; - return *this; - } - - operator const VkDeviceEventInfoEXT&() const - { - return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this); - } - - bool operator==( DeviceEventInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( deviceEvent == rhs.deviceEvent ); - } - - bool operator!=( DeviceEventInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceEventInfoEXT; - - public: - const void* pNext = nullptr; - DeviceEventTypeEXT deviceEvent; - }; - static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); - - enum class DisplayEventTypeEXT - { - eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - }; - - struct DisplayEventInfoEXT - { - DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut ) - : displayEvent( displayEvent_ ) - { - } - - DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); - } - - DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); - return *this; - } - DisplayEventInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ ) - { - displayEvent = displayEvent_; - return *this; - } - - operator const VkDisplayEventInfoEXT&() const - { - return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this); - } - - bool operator==( DisplayEventInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( displayEvent == rhs.displayEvent ); - } - - bool operator!=( DisplayEventInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDisplayEventInfoEXT; - - public: - const void* pNext = nullptr; - DisplayEventTypeEXT displayEvent; - }; - static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); - - enum class PeerMemoryFeatureFlagBitsKHX - { - eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX, - eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX, - eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX, - eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX - }; - - using PeerMemoryFeatureFlagsKHX = Flags<PeerMemoryFeatureFlagBitsKHX, VkPeerMemoryFeatureFlagsKHX>; - - VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX operator|( PeerMemoryFeatureFlagBitsKHX bit0, PeerMemoryFeatureFlagBitsKHX bit1 ) - { - return PeerMemoryFeatureFlagsKHX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX operator~( PeerMemoryFeatureFlagBitsKHX bits ) - { - return ~( PeerMemoryFeatureFlagsKHX( bits ) ); - } - - template <> struct FlagTraits<PeerMemoryFeatureFlagBitsKHX> - { - enum - { - allFlags = VkFlags(PeerMemoryFeatureFlagBitsKHX::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eGenericDst) - }; - }; - - enum class MemoryAllocateFlagBitsKHX - { - eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX - }; - - using MemoryAllocateFlagsKHX = Flags<MemoryAllocateFlagBitsKHX, VkMemoryAllocateFlagsKHX>; - - VULKAN_HPP_INLINE MemoryAllocateFlagsKHX operator|( MemoryAllocateFlagBitsKHX bit0, MemoryAllocateFlagBitsKHX bit1 ) - { - return MemoryAllocateFlagsKHX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE MemoryAllocateFlagsKHX operator~( MemoryAllocateFlagBitsKHX bits ) - { - return ~( MemoryAllocateFlagsKHX( bits ) ); - } - - template <> struct FlagTraits<MemoryAllocateFlagBitsKHX> - { - enum - { - allFlags = VkFlags(MemoryAllocateFlagBitsKHX::eDeviceMask) - }; - }; - - struct MemoryAllocateFlagsInfoKHX - { - MemoryAllocateFlagsInfoKHX( MemoryAllocateFlagsKHX flags_ = MemoryAllocateFlagsKHX(), uint32_t deviceMask_ = 0 ) - : flags( flags_ ) - , deviceMask( deviceMask_ ) - { - } - - MemoryAllocateFlagsInfoKHX( VkMemoryAllocateFlagsInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) ); - } - - MemoryAllocateFlagsInfoKHX& operator=( VkMemoryAllocateFlagsInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) ); - return *this; - } - MemoryAllocateFlagsInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - MemoryAllocateFlagsInfoKHX& setFlags( MemoryAllocateFlagsKHX flags_ ) - { - flags = flags_; - return *this; - } - - MemoryAllocateFlagsInfoKHX& setDeviceMask( uint32_t deviceMask_ ) - { - deviceMask = deviceMask_; - return *this; - } - - operator const VkMemoryAllocateFlagsInfoKHX&() const - { - return *reinterpret_cast<const VkMemoryAllocateFlagsInfoKHX*>(this); - } - - bool operator==( MemoryAllocateFlagsInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( deviceMask == rhs.deviceMask ); - } - - bool operator!=( MemoryAllocateFlagsInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eMemoryAllocateFlagsInfoKHX; - - public: - const void* pNext = nullptr; - MemoryAllocateFlagsKHX flags; - uint32_t deviceMask; - }; - static_assert( sizeof( MemoryAllocateFlagsInfoKHX ) == sizeof( VkMemoryAllocateFlagsInfoKHX ), "struct and wrapper have different size!" ); - - enum class DeviceGroupPresentModeFlagBitsKHX - { - eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX, - eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX, - eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX, - eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX - }; - - using DeviceGroupPresentModeFlagsKHX = Flags<DeviceGroupPresentModeFlagBitsKHX, VkDeviceGroupPresentModeFlagsKHX>; - - VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHX operator|( DeviceGroupPresentModeFlagBitsKHX bit0, DeviceGroupPresentModeFlagBitsKHX bit1 ) - { - return DeviceGroupPresentModeFlagsKHX( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHX operator~( DeviceGroupPresentModeFlagBitsKHX bits ) - { - return ~( DeviceGroupPresentModeFlagsKHX( bits ) ); - } - - template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHX> - { - enum - { - allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHX::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice) - }; - }; - - struct DeviceGroupPresentCapabilitiesKHX - { - operator const VkDeviceGroupPresentCapabilitiesKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHX*>(this); - } - - bool operator==( DeviceGroupPresentCapabilitiesKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE_KHX * sizeof( uint32_t ) ) == 0 ) - && ( modes == rhs.modes ); - } - - bool operator!=( DeviceGroupPresentCapabilitiesKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHX; - - public: - const void* pNext = nullptr; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX]; - DeviceGroupPresentModeFlagsKHX modes; - }; - static_assert( sizeof( DeviceGroupPresentCapabilitiesKHX ) == sizeof( VkDeviceGroupPresentCapabilitiesKHX ), "struct and wrapper have different size!" ); - - struct DeviceGroupPresentInfoKHX - { - DeviceGroupPresentInfoKHX( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, DeviceGroupPresentModeFlagBitsKHX mode_ = DeviceGroupPresentModeFlagBitsKHX::eLocal ) - : swapchainCount( swapchainCount_ ) - , pDeviceMasks( pDeviceMasks_ ) - , mode( mode_ ) - { - } - - DeviceGroupPresentInfoKHX( VkDeviceGroupPresentInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) ); - } - - DeviceGroupPresentInfoKHX& operator=( VkDeviceGroupPresentInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) ); - return *this; - } - DeviceGroupPresentInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupPresentInfoKHX& setSwapchainCount( uint32_t swapchainCount_ ) - { - swapchainCount = swapchainCount_; - return *this; - } - - DeviceGroupPresentInfoKHX& setPDeviceMasks( const uint32_t* pDeviceMasks_ ) - { - pDeviceMasks = pDeviceMasks_; - return *this; - } - - DeviceGroupPresentInfoKHX& setMode( DeviceGroupPresentModeFlagBitsKHX mode_ ) - { - mode = mode_; - return *this; - } - - operator const VkDeviceGroupPresentInfoKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupPresentInfoKHX*>(this); - } - - bool operator==( DeviceGroupPresentInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( swapchainCount == rhs.swapchainCount ) - && ( pDeviceMasks == rhs.pDeviceMasks ) - && ( mode == rhs.mode ); - } - - bool operator!=( DeviceGroupPresentInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupPresentInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - DeviceGroupPresentModeFlagBitsKHX mode; - }; - static_assert( sizeof( DeviceGroupPresentInfoKHX ) == sizeof( VkDeviceGroupPresentInfoKHX ), "struct and wrapper have different size!" ); - - struct DeviceGroupSwapchainCreateInfoKHX - { - DeviceGroupSwapchainCreateInfoKHX( DeviceGroupPresentModeFlagsKHX modes_ = DeviceGroupPresentModeFlagsKHX() ) - : modes( modes_ ) - { - } - - DeviceGroupSwapchainCreateInfoKHX( VkDeviceGroupSwapchainCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) ); - } - - DeviceGroupSwapchainCreateInfoKHX& operator=( VkDeviceGroupSwapchainCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) ); - return *this; - } - DeviceGroupSwapchainCreateInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupSwapchainCreateInfoKHX& setModes( DeviceGroupPresentModeFlagsKHX modes_ ) - { - modes = modes_; - return *this; - } - - operator const VkDeviceGroupSwapchainCreateInfoKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHX*>(this); - } - - bool operator==( DeviceGroupSwapchainCreateInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( modes == rhs.modes ); - } - - bool operator!=( DeviceGroupSwapchainCreateInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHX; - - public: - const void* pNext = nullptr; - DeviceGroupPresentModeFlagsKHX modes; - }; - static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHX ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHX ), "struct and wrapper have different size!" ); - - enum class SwapchainCreateFlagBitsKHR - { - eBindSfrKHX = VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX - }; - - using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>; - - VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 ) - { - return SwapchainCreateFlagsKHR( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits ) - { - return ~( SwapchainCreateFlagsKHR( bits ) ); - } - - template <> struct FlagTraits<SwapchainCreateFlagBitsKHR> - { - enum - { - allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eBindSfrKHX) - }; - }; - - struct SwapchainCreateInfoKHR - { - 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() ) - : flags( flags_ ) - , surface( surface_ ) - , minImageCount( minImageCount_ ) - , imageFormat( imageFormat_ ) - , imageColorSpace( imageColorSpace_ ) - , imageExtent( imageExtent_ ) - , imageArrayLayers( imageArrayLayers_ ) - , imageUsage( imageUsage_ ) - , imageSharingMode( imageSharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , preTransform( preTransform_ ) - , compositeAlpha( compositeAlpha_ ) - , presentMode( presentMode_ ) - , clipped( clipped_ ) - , oldSwapchain( oldSwapchain_ ) - { - } - - SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); - } - - SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); - return *this; - } - SwapchainCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ ) - { - flags = flags_; - return *this; - } - - SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ ) - { - surface = surface_; - return *this; - } - - SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ ) - { - minImageCount = minImageCount_; - return *this; - } - - SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ ) - { - imageFormat = imageFormat_; - return *this; - } - - SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ ) - { - imageColorSpace = imageColorSpace_; - return *this; - } - - SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ ) - { - imageExtent = imageExtent_; - return *this; - } - - SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ ) - { - imageArrayLayers = imageArrayLayers_; - return *this; - } - - SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ ) - { - imageUsage = imageUsage_; - return *this; - } - - SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ ) - { - imageSharingMode = imageSharingMode_; - return *this; - } - - SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ ) - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ ) - { - preTransform = preTransform_; - return *this; - } - - SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ ) - { - compositeAlpha = compositeAlpha_; - return *this; - } - - SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ ) - { - presentMode = presentMode_; - return *this; - } - - SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ ) - { - clipped = clipped_; - return *this; - } - - SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ ) - { - oldSwapchain = oldSwapchain_; - return *this; - } - - operator const VkSwapchainCreateInfoKHR&() const - { - return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this); - } - - bool operator==( SwapchainCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( surface == rhs.surface ) - && ( minImageCount == rhs.minImageCount ) - && ( imageFormat == rhs.imageFormat ) - && ( imageColorSpace == rhs.imageColorSpace ) - && ( imageExtent == rhs.imageExtent ) - && ( imageArrayLayers == rhs.imageArrayLayers ) - && ( imageUsage == rhs.imageUsage ) - && ( imageSharingMode == rhs.imageSharingMode ) - && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) - && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) - && ( preTransform == rhs.preTransform ) - && ( compositeAlpha == rhs.compositeAlpha ) - && ( presentMode == rhs.presentMode ) - && ( clipped == rhs.clipped ) - && ( oldSwapchain == rhs.oldSwapchain ); - } - - bool operator!=( SwapchainCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSwapchainCreateInfoKHR; - - public: - const void* pNext = nullptr; - SwapchainCreateFlagsKHR flags; - SurfaceKHR surface; - uint32_t minImageCount; - Format imageFormat; - ColorSpaceKHR imageColorSpace; - Extent2D imageExtent; - uint32_t imageArrayLayers; - ImageUsageFlags imageUsage; - SharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - SurfaceTransformFlagBitsKHR preTransform; - CompositeAlphaFlagBitsKHR compositeAlpha; - PresentModeKHR presentMode; - Bool32 clipped; - SwapchainKHR oldSwapchain; - }; - static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); - - enum class ViewportCoordinateSwizzleNV - { - ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, - eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, - ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, - eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, - ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, - eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, - ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, - eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - }; - - struct ViewportSwizzleNV - { - ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX ) - : x( x_ ) - , y( y_ ) - , z( z_ ) - , w( w_ ) - { - } - - ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); - } - - ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) - { - memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); - return *this; - } - ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ ) - { - x = x_; - return *this; - } - - ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ ) - { - y = y_; - return *this; - } - - ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ ) - { - z = z_; - return *this; - } - - ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ ) - { - w = w_; - return *this; - } - - operator const VkViewportSwizzleNV&() const - { - return *reinterpret_cast<const VkViewportSwizzleNV*>(this); - } - - bool operator==( ViewportSwizzleNV const& rhs ) const - { - return ( x == rhs.x ) - && ( y == rhs.y ) - && ( z == rhs.z ) - && ( w == rhs.w ); - } - - bool operator!=( ViewportSwizzleNV const& rhs ) const - { - return !operator==( rhs ); - } - - ViewportCoordinateSwizzleNV x; - ViewportCoordinateSwizzleNV y; - ViewportCoordinateSwizzleNV z; - ViewportCoordinateSwizzleNV w; - }; - static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); - - struct PipelineViewportSwizzleStateCreateInfoNV - { - PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewportSwizzles( pViewportSwizzles_ ) - { - } - - PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); - } - - PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); - return *this; - } - PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ ) - { - flags = flags_; - return *this; - } - - PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ ) - { - viewportCount = viewportCount_; - return *this; - } - - PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ ) - { - pViewportSwizzles = pViewportSwizzles_; - return *this; - } - - operator const VkPipelineViewportSwizzleStateCreateInfoNV&() const - { - return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this); - } - - bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( viewportCount == rhs.viewportCount ) - && ( pViewportSwizzles == rhs.pViewportSwizzles ); - } - - bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; - - public: - const void* pNext = nullptr; - PipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const ViewportSwizzleNV* pViewportSwizzles; - }; - static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" ); - - enum class DiscardRectangleModeEXT - { - eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, - eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - }; - - struct PipelineDiscardRectangleStateCreateInfoEXT - { - PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const Rect2D* pDiscardRectangles_ = nullptr ) - : flags( flags_ ) - , discardRectangleMode( discardRectangleMode_ ) - , discardRectangleCount( discardRectangleCount_ ) - , pDiscardRectangles( pDiscardRectangles_ ) - { - } - - PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); - } - - PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); - return *this; - } - PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ ) - { - discardRectangleMode = discardRectangleMode_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ ) - { - discardRectangleCount = discardRectangleCount_; - return *this; - } - - PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ ) - { - pDiscardRectangles = pDiscardRectangles_; - return *this; - } - - operator const VkPipelineDiscardRectangleStateCreateInfoEXT&() const - { - return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this); - } - - bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( discardRectangleMode == rhs.discardRectangleMode ) - && ( discardRectangleCount == rhs.discardRectangleCount ) - && ( pDiscardRectangles == rhs.pDiscardRectangles ); - } - - bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - PipelineDiscardRectangleStateCreateFlagsEXT flags; - DiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const Rect2D* pDiscardRectangles; - }; - static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class SubpassDescriptionFlagBits - { - ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, - ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX - }; - - using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>; - - VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 ) - { - return SubpassDescriptionFlags( bit0 ) | bit1; - } - - VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits ) - { - return ~( SubpassDescriptionFlags( bits ) ); - } - - template <> struct FlagTraits<SubpassDescriptionFlagBits> - { - enum - { - allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) - }; - }; - - struct SubpassDescription - { - 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 ) - : flags( flags_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , inputAttachmentCount( inputAttachmentCount_ ) - , pInputAttachments( pInputAttachments_ ) - , colorAttachmentCount( colorAttachmentCount_ ) - , pColorAttachments( pColorAttachments_ ) - , pResolveAttachments( pResolveAttachments_ ) - , pDepthStencilAttachment( pDepthStencilAttachment_ ) - , preserveAttachmentCount( preserveAttachmentCount_ ) - , pPreserveAttachments( pPreserveAttachments_ ) - { - } - - SubpassDescription( VkSubpassDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDescription ) ); - } - - SubpassDescription& operator=( VkSubpassDescription const & rhs ) - { - memcpy( this, &rhs, sizeof( SubpassDescription ) ); - return *this; - } - SubpassDescription& setFlags( SubpassDescriptionFlags flags_ ) - { - flags = flags_; - return *this; - } - - SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ ) - { - inputAttachmentCount = inputAttachmentCount_; - return *this; - } - - SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ ) - { - pInputAttachments = pInputAttachments_; - return *this; - } - - SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ ) - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ ) - { - pColorAttachments = pColorAttachments_; - return *this; - } - - SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ ) - { - pResolveAttachments = pResolveAttachments_; - return *this; - } - - SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ ) - { - pDepthStencilAttachment = pDepthStencilAttachment_; - return *this; - } - - SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) - { - preserveAttachmentCount = preserveAttachmentCount_; - return *this; - } - - SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ ) - { - pPreserveAttachments = pPreserveAttachments_; - return *this; - } - - operator const VkSubpassDescription&() const - { - return *reinterpret_cast<const VkSubpassDescription*>(this); - } - - bool operator==( SubpassDescription const& rhs ) const - { - return ( flags == rhs.flags ) - && ( pipelineBindPoint == rhs.pipelineBindPoint ) - && ( inputAttachmentCount == rhs.inputAttachmentCount ) - && ( pInputAttachments == rhs.pInputAttachments ) - && ( colorAttachmentCount == rhs.colorAttachmentCount ) - && ( pColorAttachments == rhs.pColorAttachments ) - && ( pResolveAttachments == rhs.pResolveAttachments ) - && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) - && ( preserveAttachmentCount == rhs.preserveAttachmentCount ) - && ( pPreserveAttachments == rhs.pPreserveAttachments ); - } - - bool operator!=( SubpassDescription const& rhs ) const - { - return !operator==( rhs ); - } - - SubpassDescriptionFlags flags; - PipelineBindPoint pipelineBindPoint; - uint32_t inputAttachmentCount; - const AttachmentReference* pInputAttachments; - uint32_t colorAttachmentCount; - const AttachmentReference* pColorAttachments; - const AttachmentReference* pResolveAttachments; - const AttachmentReference* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; - }; - static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" ); - - struct RenderPassCreateInfo - { - 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 ) - : flags( flags_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , subpassCount( subpassCount_ ) - , pSubpasses( pSubpasses_ ) - , dependencyCount( dependencyCount_ ) - , pDependencies( pDependencies_ ) - { - } - - RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); - } - - RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); - return *this; - } - RenderPassCreateInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ ) - { - flags = flags_; - return *this; - } - - RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ ) - { - attachmentCount = attachmentCount_; - return *this; - } - - RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ ) - { - pAttachments = pAttachments_; - return *this; - } - - RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ ) - { - subpassCount = subpassCount_; - return *this; - } - - RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ ) - { - pSubpasses = pSubpasses_; - return *this; - } - - RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ ) - { - dependencyCount = dependencyCount_; - return *this; - } - - RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ ) - { - pDependencies = pDependencies_; - return *this; - } - - operator const VkRenderPassCreateInfo&() const - { - return *reinterpret_cast<const VkRenderPassCreateInfo*>(this); - } - - bool operator==( RenderPassCreateInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( attachmentCount == rhs.attachmentCount ) - && ( pAttachments == rhs.pAttachments ) - && ( subpassCount == rhs.subpassCount ) - && ( pSubpasses == rhs.pSubpasses ) - && ( dependencyCount == rhs.dependencyCount ) - && ( pDependencies == rhs.pDependencies ); - } - - bool operator!=( RenderPassCreateInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eRenderPassCreateInfo; - - public: - const void* pNext = nullptr; - RenderPassCreateFlags flags; - uint32_t attachmentCount; - const AttachmentDescription* pAttachments; - uint32_t subpassCount; - const SubpassDescription* pSubpasses; - uint32_t dependencyCount; - const SubpassDependency* pDependencies; - }; - static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); - - enum class PointClippingBehaviorKHR - { - eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR, - eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR - }; - - struct PhysicalDevicePointClippingPropertiesKHR - { - operator const VkPhysicalDevicePointClippingPropertiesKHR&() const - { - return *reinterpret_cast<const VkPhysicalDevicePointClippingPropertiesKHR*>(this); - } - - bool operator==( PhysicalDevicePointClippingPropertiesKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( pointClippingBehavior == rhs.pointClippingBehavior ); - } - - bool operator!=( PhysicalDevicePointClippingPropertiesKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDevicePointClippingPropertiesKHR; - - public: - void* pNext = nullptr; - PointClippingBehaviorKHR pointClippingBehavior; - }; - static_assert( sizeof( PhysicalDevicePointClippingPropertiesKHR ) == sizeof( VkPhysicalDevicePointClippingPropertiesKHR ), "struct and wrapper have different size!" ); - - enum class SamplerReductionModeEXT - { - eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, - eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT, - eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT - }; - - struct SamplerReductionModeCreateInfoEXT - { - SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage ) - : reductionMode( reductionMode_ ) - { - } - - SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); - } - - SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); - return *this; - } - SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ ) - { - reductionMode = reductionMode_; - return *this; - } - - operator const VkSamplerReductionModeCreateInfoEXT&() const - { - return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(this); - } - - bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( reductionMode == rhs.reductionMode ); - } - - bool operator!=( SamplerReductionModeCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; - - public: - const void* pNext = nullptr; - SamplerReductionModeEXT reductionMode; - }; - static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class TessellationDomainOriginKHR - { - eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR, - eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR - }; - - struct PipelineTessellationDomainOriginStateCreateInfoKHR - { - PipelineTessellationDomainOriginStateCreateInfoKHR( TessellationDomainOriginKHR domainOrigin_ = TessellationDomainOriginKHR::eUpperLeft ) - : domainOrigin( domainOrigin_ ) - { - } - - PipelineTessellationDomainOriginStateCreateInfoKHR( VkPipelineTessellationDomainOriginStateCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) ); - } - - PipelineTessellationDomainOriginStateCreateInfoKHR& operator=( VkPipelineTessellationDomainOriginStateCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) ); - return *this; - } - PipelineTessellationDomainOriginStateCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineTessellationDomainOriginStateCreateInfoKHR& setDomainOrigin( TessellationDomainOriginKHR domainOrigin_ ) - { - domainOrigin = domainOrigin_; - return *this; - } - - operator const VkPipelineTessellationDomainOriginStateCreateInfoKHR&() const - { - return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfoKHR*>(this); - } - - bool operator==( PipelineTessellationDomainOriginStateCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( domainOrigin == rhs.domainOrigin ); - } - - bool operator!=( PipelineTessellationDomainOriginStateCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR; - - public: - const void* pNext = nullptr; - TessellationDomainOriginKHR domainOrigin; - }; - static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfoKHR ), "struct and wrapper have different size!" ); - - enum class SamplerYcbcrModelConversionKHR - { - eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR, - eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR, - eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR, - eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR, - eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR - }; - - enum class SamplerYcbcrRangeKHR - { - eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR, - eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR - }; - - enum class ChromaLocationKHR - { - eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN_KHR, - eMidpoint = VK_CHROMA_LOCATION_MIDPOINT_KHR - }; - - struct SamplerYcbcrConversionCreateInfoKHR - { - SamplerYcbcrConversionCreateInfoKHR( Format format_ = Format::eUndefined, SamplerYcbcrModelConversionKHR ycbcrModel_ = SamplerYcbcrModelConversionKHR::eRgbIdentity, SamplerYcbcrRangeKHR ycbcrRange_ = SamplerYcbcrRangeKHR::eItuFull, ComponentMapping components_ = ComponentMapping(), ChromaLocationKHR xChromaOffset_ = ChromaLocationKHR::eCositedEven, ChromaLocationKHR yChromaOffset_ = ChromaLocationKHR::eCositedEven, Filter chromaFilter_ = Filter::eNearest, Bool32 forceExplicitReconstruction_ = 0 ) - : format( format_ ) - , ycbcrModel( ycbcrModel_ ) - , ycbcrRange( ycbcrRange_ ) - , components( components_ ) - , xChromaOffset( xChromaOffset_ ) - , yChromaOffset( yChromaOffset_ ) - , chromaFilter( chromaFilter_ ) - , forceExplicitReconstruction( forceExplicitReconstruction_ ) - { - } - - SamplerYcbcrConversionCreateInfoKHR( VkSamplerYcbcrConversionCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfoKHR ) ); - } - - SamplerYcbcrConversionCreateInfoKHR& operator=( VkSamplerYcbcrConversionCreateInfoKHR const & rhs ) - { - memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfoKHR ) ); - return *this; - } - SamplerYcbcrConversionCreateInfoKHR& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setFormat( Format format_ ) - { - format = format_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setYcbcrModel( SamplerYcbcrModelConversionKHR ycbcrModel_ ) - { - ycbcrModel = ycbcrModel_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setYcbcrRange( SamplerYcbcrRangeKHR ycbcrRange_ ) - { - ycbcrRange = ycbcrRange_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setComponents( ComponentMapping components_ ) - { - components = components_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setXChromaOffset( ChromaLocationKHR xChromaOffset_ ) - { - xChromaOffset = xChromaOffset_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setYChromaOffset( ChromaLocationKHR yChromaOffset_ ) - { - yChromaOffset = yChromaOffset_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setChromaFilter( Filter chromaFilter_ ) - { - chromaFilter = chromaFilter_; - return *this; - } - - SamplerYcbcrConversionCreateInfoKHR& setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ ) - { - forceExplicitReconstruction = forceExplicitReconstruction_; - return *this; - } - - operator const VkSamplerYcbcrConversionCreateInfoKHR&() const - { - return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>(this); - } - - bool operator==( SamplerYcbcrConversionCreateInfoKHR const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( format == rhs.format ) - && ( ycbcrModel == rhs.ycbcrModel ) - && ( ycbcrRange == rhs.ycbcrRange ) - && ( components == rhs.components ) - && ( xChromaOffset == rhs.xChromaOffset ) - && ( yChromaOffset == rhs.yChromaOffset ) - && ( chromaFilter == rhs.chromaFilter ) - && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction ); - } - - bool operator!=( SamplerYcbcrConversionCreateInfoKHR const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfoKHR; - - public: - const void* pNext = nullptr; - Format format; - SamplerYcbcrModelConversionKHR ycbcrModel; - SamplerYcbcrRangeKHR ycbcrRange; - ComponentMapping components; - ChromaLocationKHR xChromaOffset; - ChromaLocationKHR yChromaOffset; - Filter chromaFilter; - Bool32 forceExplicitReconstruction; - }; - static_assert( sizeof( SamplerYcbcrConversionCreateInfoKHR ) == sizeof( VkSamplerYcbcrConversionCreateInfoKHR ), "struct and wrapper have different size!" ); - - enum class BlendOverlapEXT - { - eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, - eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, - eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT - }; - - struct PipelineColorBlendAdvancedStateCreateInfoEXT - { - PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, Bool32 dstPremultiplied_ = 0, BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated ) - : srcPremultiplied( srcPremultiplied_ ) - , dstPremultiplied( dstPremultiplied_ ) - , blendOverlap( blendOverlap_ ) - { - } - - PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); - return *this; - } - PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ ) - { - srcPremultiplied = srcPremultiplied_; - return *this; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ ) - { - dstPremultiplied = dstPremultiplied_; - return *this; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ ) - { - blendOverlap = blendOverlap_; - return *this; - } - - operator const VkPipelineColorBlendAdvancedStateCreateInfoEXT&() const - { - return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this); - } - - bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( srcPremultiplied == rhs.srcPremultiplied ) - && ( dstPremultiplied == rhs.dstPremultiplied ) - && ( blendOverlap == rhs.blendOverlap ); - } - - bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - Bool32 srcPremultiplied; - Bool32 dstPremultiplied; - BlendOverlapEXT blendOverlap; - }; - static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class CoverageModulationModeNV - { - eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV, - eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV, - eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV, - eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV - }; - - struct PipelineCoverageModulationStateCreateInfoNV - { - PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr ) - : flags( flags_ ) - , coverageModulationMode( coverageModulationMode_ ) - , coverageModulationTableEnable( coverageModulationTableEnable_ ) - , coverageModulationTableCount( coverageModulationTableCount_ ) - , pCoverageModulationTable( pCoverageModulationTable_ ) - { - } - - PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); - } - - PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); - return *this; - } - PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) - { - flags = flags_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) - { - coverageModulationMode = coverageModulationMode_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) - { - coverageModulationTableEnable = coverageModulationTableEnable_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) - { - coverageModulationTableCount = coverageModulationTableCount_; - return *this; - } - - PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ ) - { - pCoverageModulationTable = pCoverageModulationTable_; - return *this; - } - - operator const VkPipelineCoverageModulationStateCreateInfoNV&() const - { - return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(this); - } - - bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( coverageModulationMode == rhs.coverageModulationMode ) - && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) - && ( coverageModulationTableCount == rhs.coverageModulationTableCount ) - && ( pCoverageModulationTable == rhs.pCoverageModulationTable ); - } - - bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; - - public: - const void* pNext = nullptr; - PipelineCoverageModulationStateCreateFlagsNV flags; - CoverageModulationModeNV coverageModulationMode; - Bool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; - }; - static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" ); - - enum class ValidationCacheHeaderVersionEXT - { - eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - }; - - enum class ShaderInfoTypeAMD - { - eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD, - eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD, - eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - }; - - enum class QueueGlobalPriorityEXT - { - eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, - eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT, - eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT, - eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - }; - - struct DeviceQueueGlobalPriorityCreateInfoEXT - { - DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow ) - : globalPriority( globalPriority_ ) - { - } - - DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); - } - - DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) ); - return *this; - } - DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ ) - { - globalPriority = globalPriority_; - return *this; - } - - operator const VkDeviceQueueGlobalPriorityCreateInfoEXT&() const - { - return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this); - } - - bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( globalPriority == rhs.globalPriority ); - } - - bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; - - public: - const void* pNext = nullptr; - QueueGlobalPriorityEXT globalPriority; - }; - static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); - - enum class ConservativeRasterizationModeEXT - { - eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, - eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, - eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - }; - - struct PipelineRasterizationConservativeStateCreateInfoEXT - { - PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(), ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled, float extraPrimitiveOverestimationSize_ = 0 ) - : flags( flags_ ) - , conservativeRasterizationMode( conservativeRasterizationMode_ ) - , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ ) - { - } - - PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) ); - } - - PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) - { - memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) ); - return *this; - } - PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ ) - { - flags = flags_; - return *this; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ ) - { - conservativeRasterizationMode = conservativeRasterizationMode_; - return *this; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ ) - { - extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_; - return *this; - } - - operator const VkPipelineRasterizationConservativeStateCreateInfoEXT&() const - { - return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this); - } - - bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( flags == rhs.flags ) - && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) - && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); - } - - bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; - - public: - const void* pNext = nullptr; - PipelineRasterizationConservativeStateCreateFlagsEXT flags; - ConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; - }; - static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" ); - - Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ); -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<LayerProperties>> - typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(); -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) - { - return static_cast<Result>( vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties() - { - std::vector<LayerProperties,Allocator> properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast<Result>( vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast<Result>( vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::enumerateInstanceLayerProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ); -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<ExtensionProperties>> - typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr ); -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) - { - return static_cast<Result>( vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName ) - { - std::vector<ExtensionProperties,Allocator> properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast<Result>( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast<Result>( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::enumerateInstanceExtensionProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - // forward declarations - struct CmdProcessCommandsInfoNVX; - - class CommandBuffer - { - public: - CommandBuffer() - : m_commandBuffer(VK_NULL_HANDLE) - {} - - CommandBuffer( std::nullptr_t ) - : m_commandBuffer(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) - : m_commandBuffer( commandBuffer ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandBuffer & operator=(VkCommandBuffer commandBuffer) - { - m_commandBuffer = commandBuffer; - return *this; - } -#endif - - CommandBuffer & operator=( std::nullptr_t ) - { - m_commandBuffer = VK_NULL_HANDLE; - return *this; - } - - bool operator==( CommandBuffer const & rhs ) const - { - return m_commandBuffer == rhs.m_commandBuffer; - } - - bool operator!=(CommandBuffer const & rhs ) const - { - return m_commandBuffer != rhs.m_commandBuffer; - } - - bool operator<(CommandBuffer const & rhs ) const - { - return m_commandBuffer < rhs.m_commandBuffer; - } - - Result begin( const CommandBufferBeginInfo* pBeginInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result end() const; -#else - ResultValueType<void>::type end() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result reset( CommandBufferResetFlags flags ) const; -#else - ResultValueType<void>::type reset( CommandBufferResetFlags flags ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline ) const; - - void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void setLineWidth( float lineWidth ) const; - - void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const; - - void setBlendConstants( const float blendConstants[4] ) const; - - void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const; - - void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const; - - void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const; - - void setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const; - - void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType ) const; - - void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const; - - void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const; - - void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const; - - void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const; - - void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const; - - void dispatchIndirect( Buffer buffer, DeviceSize offset ) const; - - void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename T> - void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const; - - void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void setEvent( Event event, PipelineStageFlags stageMask ) const; - - void resetEvent( Event event, PipelineStageFlags stageMask ) 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 ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - 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 ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const; - - void endQuery( QueryPool queryPool, uint32_t query ) const; - - void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const; - - void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query ) const; - - void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags ) const; - - void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename T> - void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void nextSubpass( SubpassContents contents ) const; - - void endRenderPass() const; - - void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void debugMarkerEndEXT() const; - - void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const; - - void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const; - - void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void setDeviceMaskKHX( uint32_t deviceMask ) const; - - void dispatchBaseKHX( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const; - - void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData ) const; - - void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const - { - return m_commandBuffer; - } - - explicit operator bool() const - { - return m_commandBuffer != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_commandBuffer == VK_NULL_HANDLE; - } - - private: - VkCommandBuffer m_commandBuffer; - }; - - static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); - - VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo ) const - { - return static_cast<Result>( vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( pBeginInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo ) const - { - Result result = static_cast<Result>( vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( &beginInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::CommandBuffer::begin" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result CommandBuffer::end() const - { - return static_cast<Result>( vkEndCommandBuffer( m_commandBuffer ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::end() const - { - Result result = static_cast<Result>( vkEndCommandBuffer( m_commandBuffer ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::CommandBuffer::end" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags ) const - { - return static_cast<Result>( vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags ) const - { - Result result = static_cast<Result>( vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::CommandBuffer::reset" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline ) const - { - vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports ) const - { - vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports ) const - { - vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors ) const - { - vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors ) const - { - vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const - { - vkCmdSetLineWidth( m_commandBuffer, lineWidth ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const - { - vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const - { - vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds ) const - { - vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const - { - vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const - { - vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const - { - vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference ); - } - - 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 ) const - { - vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets ) const - { - vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType ) const - { - vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) ); - } - - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets ) const - { - vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( buffers.size() == offsets.size() ); -#else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( "VULKAN_HPP_NAMESPACE::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const - { - vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); - } - - VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const - { - vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); - } - - VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const - { - vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride ); - } - - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const - { - vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride ); - } - - VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const - { - vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ ); - } - - VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset ) const - { - vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset ); - } - - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions ) const - { - vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions ) const - { - vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions ) const - { - 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 ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions ) const - { - 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() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter ) const - { - 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 ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter ) const - { - 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 ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions ) const - { - vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions ) const - { - vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions ) const - { - vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions ) const - { - vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData ) const - { - vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, dataSize, pData ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename T> - VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data ) const - { - vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const - { - vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data ); - } - - VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const - { - vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( pColor ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges ) const - { - vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( &color ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const - { - vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( pDepthStencil ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges ) const - { - vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( &depthStencil ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects ) const - { - vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects ) const - { - vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions ) const - { - 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 ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions ) const - { - 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() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask ) const - { - vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); - } - - VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask ) const - { - vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); - } - - 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 ) const - { - 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 ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const - { - 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() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - 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 ) const - { - 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 ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const - { - 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() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const - { - vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) ); - } - - VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query ) const - { - vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query ); - } - - VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const - { - vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); - } - - VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query ) const - { - vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query ); - } - - VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags ) const - { - vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) ); - } - - VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const - { - vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename T> - VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values ) const - { - vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents ) const - { - vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const - { - vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents ) const - { - vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) ); - } - - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const - { - vkCmdEndRenderPass( m_commandBuffer ); - } - - VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const - { - vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const CommandBuffer> commandBuffers ) const - { - vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const - { - vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const - { - vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const - { - vkCmdDebugMarkerEndEXT( m_commandBuffer ); - } - - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const - { - vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const - { - vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const - { - vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } - - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const - { - vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride ); - } - - VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const - { - vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( pProcessCommandsInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo ) const - { - vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( &processCommandsInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const - { - vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( pReserveSpaceInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo ) const - { - vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( &reserveSpaceInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites ) const - { - vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites ) const - { - vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHX( uint32_t deviceMask ) const - { - vkCmdSetDeviceMaskKHX( m_commandBuffer, deviceMask ); - } - - VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHX( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const - { - vkCmdDispatchBaseKHX( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } - - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData ) const - { - vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData ); - } - - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings ) const - { - vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings ) const - { - vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles ) const - { - vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles ) const - { - vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo ) const - { - vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( pSampleLocationsInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const - { - vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( &sampleLocationsInfo ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - struct SubmitInfo - { - 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 ) - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , pWaitDstStageMask( pWaitDstStageMask_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBuffers( pCommandBuffers_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - { - } - - SubmitInfo( VkSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SubmitInfo ) ); - } - - SubmitInfo& operator=( VkSubmitInfo const & rhs ) - { - memcpy( this, &rhs, sizeof( SubmitInfo ) ); - return *this; - } - SubmitInfo& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - SubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - SubmitInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ ) - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - SubmitInfo& setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ ) - { - pWaitDstStageMask = pWaitDstStageMask_; - return *this; - } - - SubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ ) - { - commandBufferCount = commandBufferCount_; - return *this; - } - - SubmitInfo& setPCommandBuffers( const CommandBuffer* pCommandBuffers_ ) - { - pCommandBuffers = pCommandBuffers_; - return *this; - } - - SubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - SubmitInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ ) - { - pSignalSemaphores = pSignalSemaphores_; - return *this; - } - - operator const VkSubmitInfo&() const - { - return *reinterpret_cast<const VkSubmitInfo*>(this); - } - - bool operator==( SubmitInfo const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) - && ( pWaitSemaphores == rhs.pWaitSemaphores ) - && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) - && ( commandBufferCount == rhs.commandBufferCount ) - && ( pCommandBuffers == rhs.pCommandBuffers ) - && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) - && ( pSignalSemaphores == rhs.pSignalSemaphores ); - } - - bool operator!=( SubmitInfo const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eSubmitInfo; - - public: - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const Semaphore* pWaitSemaphores; - const PipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const CommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); - - class Queue - { - public: - Queue() - : m_queue(VK_NULL_HANDLE) - {} - - Queue( std::nullptr_t ) - : m_queue(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) - : m_queue( queue ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Queue & operator=(VkQueue queue) - { - m_queue = queue; - return *this; - } -#endif - - Queue & operator=( std::nullptr_t ) - { - m_queue = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Queue const & rhs ) const - { - return m_queue == rhs.m_queue; - } - - bool operator!=(Queue const & rhs ) const - { - return m_queue != rhs.m_queue; - } - - bool operator<(Queue const & rhs ) const - { - return m_queue < rhs.m_queue; - } - - Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result waitIdle() const; -#else - ResultValueType<void>::type waitIdle() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result presentKHR( const PresentInfoKHR* pPresentInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result presentKHR( const PresentInfoKHR & presentInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const - { - return m_queue; - } - - explicit operator bool() const - { - return m_queue != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_queue == VK_NULL_HANDLE; - } - - private: - VkQueue m_queue; - }; - - static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); - - VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const - { - return static_cast<Result>( vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const SubmitInfo> submits, Fence fence ) const - { - Result result = static_cast<Result>( vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::submit" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Queue::waitIdle() const - { - return static_cast<Result>( vkQueueWaitIdle( m_queue ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Queue::waitIdle() const - { - Result result = static_cast<Result>( vkQueueWaitIdle( m_queue ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::waitIdle" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence ) const - { - return static_cast<Result>( vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence ) const - { - Result result = static_cast<Result>( vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::bindSparse" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo ) const - { - return static_cast<Result>( vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo ) const - { - Result result = static_cast<Result>( vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( &presentInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class BufferDeleter; - template <> class UniqueHandleTraits<Buffer> {public: using deleter = BufferDeleter; }; - using UniqueBuffer = UniqueHandle<Buffer>; - class BufferViewDeleter; - template <> class UniqueHandleTraits<BufferView> {public: using deleter = BufferViewDeleter; }; - using UniqueBufferView = UniqueHandle<BufferView>; - class CommandBufferDeleter; - template <> class UniqueHandleTraits<CommandBuffer> {public: using deleter = CommandBufferDeleter; }; - using UniqueCommandBuffer = UniqueHandle<CommandBuffer>; - class CommandPoolDeleter; - template <> class UniqueHandleTraits<CommandPool> {public: using deleter = CommandPoolDeleter; }; - using UniqueCommandPool = UniqueHandle<CommandPool>; - class DescriptorPoolDeleter; - template <> class UniqueHandleTraits<DescriptorPool> {public: using deleter = DescriptorPoolDeleter; }; - using UniqueDescriptorPool = UniqueHandle<DescriptorPool>; - class DescriptorSetDeleter; - template <> class UniqueHandleTraits<DescriptorSet> {public: using deleter = DescriptorSetDeleter; }; - using UniqueDescriptorSet = UniqueHandle<DescriptorSet>; - class DescriptorSetLayoutDeleter; - template <> class UniqueHandleTraits<DescriptorSetLayout> {public: using deleter = DescriptorSetLayoutDeleter; }; - using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout>; - class DescriptorUpdateTemplateKHRDeleter; - template <> class UniqueHandleTraits<DescriptorUpdateTemplateKHR> {public: using deleter = DescriptorUpdateTemplateKHRDeleter; }; - using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplateKHR>; - class DeviceMemoryDeleter; - template <> class UniqueHandleTraits<DeviceMemory> {public: using deleter = DeviceMemoryDeleter; }; - using UniqueDeviceMemory = UniqueHandle<DeviceMemory>; - class EventDeleter; - template <> class UniqueHandleTraits<Event> {public: using deleter = EventDeleter; }; - using UniqueEvent = UniqueHandle<Event>; - class FenceDeleter; - template <> class UniqueHandleTraits<Fence> {public: using deleter = FenceDeleter; }; - using UniqueFence = UniqueHandle<Fence>; - class FramebufferDeleter; - template <> class UniqueHandleTraits<Framebuffer> {public: using deleter = FramebufferDeleter; }; - using UniqueFramebuffer = UniqueHandle<Framebuffer>; - class ImageDeleter; - template <> class UniqueHandleTraits<Image> {public: using deleter = ImageDeleter; }; - using UniqueImage = UniqueHandle<Image>; - class ImageViewDeleter; - template <> class UniqueHandleTraits<ImageView> {public: using deleter = ImageViewDeleter; }; - using UniqueImageView = UniqueHandle<ImageView>; - class IndirectCommandsLayoutNVXDeleter; - template <> class UniqueHandleTraits<IndirectCommandsLayoutNVX> {public: using deleter = IndirectCommandsLayoutNVXDeleter; }; - using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX>; - class ObjectTableNVXDeleter; - template <> class UniqueHandleTraits<ObjectTableNVX> {public: using deleter = ObjectTableNVXDeleter; }; - using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX>; - class PipelineDeleter; - template <> class UniqueHandleTraits<Pipeline> {public: using deleter = PipelineDeleter; }; - using UniquePipeline = UniqueHandle<Pipeline>; - class PipelineCacheDeleter; - template <> class UniqueHandleTraits<PipelineCache> {public: using deleter = PipelineCacheDeleter; }; - using UniquePipelineCache = UniqueHandle<PipelineCache>; - class PipelineLayoutDeleter; - template <> class UniqueHandleTraits<PipelineLayout> {public: using deleter = PipelineLayoutDeleter; }; - using UniquePipelineLayout = UniqueHandle<PipelineLayout>; - class QueryPoolDeleter; - template <> class UniqueHandleTraits<QueryPool> {public: using deleter = QueryPoolDeleter; }; - using UniqueQueryPool = UniqueHandle<QueryPool>; - class RenderPassDeleter; - template <> class UniqueHandleTraits<RenderPass> {public: using deleter = RenderPassDeleter; }; - using UniqueRenderPass = UniqueHandle<RenderPass>; - class SamplerDeleter; - template <> class UniqueHandleTraits<Sampler> {public: using deleter = SamplerDeleter; }; - using UniqueSampler = UniqueHandle<Sampler>; - class SamplerYcbcrConversionKHRDeleter; - template <> class UniqueHandleTraits<SamplerYcbcrConversionKHR> {public: using deleter = SamplerYcbcrConversionKHRDeleter; }; - using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversionKHR>; - class SemaphoreDeleter; - template <> class UniqueHandleTraits<Semaphore> {public: using deleter = SemaphoreDeleter; }; - using UniqueSemaphore = UniqueHandle<Semaphore>; - class ShaderModuleDeleter; - template <> class UniqueHandleTraits<ShaderModule> {public: using deleter = ShaderModuleDeleter; }; - using UniqueShaderModule = UniqueHandle<ShaderModule>; - class SwapchainKHRDeleter; - template <> class UniqueHandleTraits<SwapchainKHR> {public: using deleter = SwapchainKHRDeleter; }; - using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR>; - class ValidationCacheEXTDeleter; - template <> class UniqueHandleTraits<ValidationCacheEXT> {public: using deleter = ValidationCacheEXTDeleter; }; - using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT>; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - class Device - { - public: - Device() - : m_device(VK_NULL_HANDLE) - {} - - Device( std::nullptr_t ) - : m_device(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) - : m_device( device ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Device & operator=(VkDevice device) - { - m_device = device; - return *this; - } -#endif - - Device & operator=( std::nullptr_t ) - { - m_device = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Device const & rhs ) const - { - return m_device == rhs.m_device; - } - - bool operator!=(Device const & rhs ) const - { - return m_device != rhs.m_device; - } - - bool operator<(Device const & rhs ) const - { - return m_device < rhs.m_device; - } - - PFN_vkVoidFunction getProcAddr( const char* pName ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PFN_vkVoidFunction getProcAddr( const std::string & name ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroy( const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroy( Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result waitIdle() const; -#else - ResultValueType<void>::type waitIdle() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueDeviceMemory>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void*>::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void unmapMemory( DeviceMemory memory ) const; - - Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - DeviceSize getMemoryCommitment( DeviceMemory memory ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - MemoryRequirements getBufferMemoryRequirements( Buffer buffer ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const; -#else - ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - MemoryRequirements getImageMemoryRequirements( Image image ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const; -#else - ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<SparseImageMemoryRequirements>> - std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueFence>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyFence( Fence fence, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result resetFences( uint32_t fenceCount, const Fence* pFences ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type resetFences( ArrayProxy<const Fence> fences ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getFenceStatus( Fence fence ) const; - - Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSemaphore>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueEvent>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyEvent( Event event, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getEventStatus( Event event ) const; - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result setEvent( Event event ) const; -#else - ResultValueType<void>::type setEvent( Event event ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result resetEvent( Event event ) const; -#else - ResultValueType<void>::type resetEvent( Event event ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueQueryPool>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename T> - Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueBuffer>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueBufferView>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueImage>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyImage( Image image, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueImageView>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueShaderModule>::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniquePipelineCache>::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<uint8_t>> - typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<Pipeline>> - typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const; - ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator = std::allocator<Pipeline>> - typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const; - ResultValueType<UniquePipeline>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<Pipeline>> - typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const; - ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator = std::allocator<Pipeline>> - typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const; - ResultValueType<UniquePipeline>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniquePipelineLayout>::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSampler>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueDescriptorSetLayout>::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueDescriptorPool>::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) const; -#else - ResultValueType<void>::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<DescriptorSet>> - typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator = std::allocator<DescriptorSet>> - typename ResultValueType<std::vector<UniqueDescriptorSet,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueFramebuffer>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueRenderPass>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Extent2D getRenderAreaGranularity( RenderPass renderPass ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueCommandPool>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const; -#else - ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<CommandBuffer>> - typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator = std::allocator<CommandBuffer>> - typename ResultValueType<std::vector<UniqueCommandBuffer,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<SwapchainKHR>> - typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const; - ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator = std::allocator<SwapchainKHR>> - typename ResultValueType<std::vector<UniqueSwapchainKHR,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const; - ResultValueType<UniqueSwapchainKHR>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSwapchainKHR>::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<Image>> - typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueIndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueObjectTableNVX>::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags ) const; -#else - void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags = CommandPoolTrimFlagsKHR() ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Fence>::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValue<uint64_t> getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PeerMemoryFeatureFlagsKHX getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfoKHR* pBindInfos ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfoKHR> bindInfos ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfoKHR* pBindInfos ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfoKHR> bindInfos ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getGroupPresentCapabilitiesKHX( DeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DeviceGroupPresentCapabilitiesKHX>::type getGroupPresentCapabilitiesKHX() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getGroupSurfacePresentModesKHX( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHX* pModes ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DeviceGroupPresentModeFlagsKHX>::type getGroupSurfacePresentModesKHX( SurfaceKHR surface ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result acquireNextImage2KHX( const AcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValue<uint32_t> acquireNextImage2KHX( const AcquireNextImageInfoKHX & acquireInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DescriptorUpdateTemplateKHR>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueDescriptorUpdateTemplateKHR>::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData ) const; - - void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSwapchainStatusKHR( SwapchainKHR swapchain ) const; - - Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>> - typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - MemoryRequirements2KHR getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const; - template <typename ...T> - StructureChain<T...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - MemoryRequirements2KHR getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const; - template <typename ...T> - StructureChain<T...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<SparseImageMemoryRequirements2KHR>> - std::vector<SparseImageMemoryRequirements2KHR,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversionKHR* pYcbcrConversion ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SamplerYcbcrConversionKHR>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSamplerYcbcrConversionKHR>::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueValidationCacheEXT>::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<uint8_t>> - typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<void>::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<uint8_t>> - typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const - { - return m_device; - } - - explicit operator bool() const - { - return m_device != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_device == VK_NULL_HANDLE; - } - - private: - VkDevice m_device; - }; - - static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class BufferDeleter - { - public: - BufferDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Buffer buffer ) - { - m_device.destroyBuffer( buffer, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class BufferViewDeleter - { - public: - BufferViewDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( BufferView bufferView ) - { - m_device.destroyBufferView( bufferView, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class CommandBufferDeleter - { - public: - CommandBufferDeleter( Device device = Device(), CommandPool commandPool = CommandPool() ) - : m_device( device ) - , m_commandPool( commandPool ) - {} - - Device getDevice() const { return m_device; } - CommandPool getCommandPool() const { return m_commandPool; } - - protected: - void destroy( CommandBuffer commandBuffer ) - { - m_device.freeCommandBuffers( m_commandPool, commandBuffer ); - } - - private: - Device m_device; - CommandPool m_commandPool; - }; - - class CommandPoolDeleter - { - public: - CommandPoolDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( CommandPool commandPool ) - { - m_device.destroyCommandPool( commandPool, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class DescriptorPoolDeleter - { - public: - DescriptorPoolDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( DescriptorPool descriptorPool ) - { - m_device.destroyDescriptorPool( descriptorPool, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class DescriptorSetDeleter - { - public: - DescriptorSetDeleter( Device device = Device(), DescriptorPool descriptorPool = DescriptorPool() ) - : m_device( device ) - , m_descriptorPool( descriptorPool ) - {} - - Device getDevice() const { return m_device; } - DescriptorPool getDescriptorPool() const { return m_descriptorPool; } - - protected: - void destroy( DescriptorSet descriptorSet ) - { - m_device.freeDescriptorSets( m_descriptorPool, descriptorSet ); - } - - private: - Device m_device; - DescriptorPool m_descriptorPool; - }; - - class DescriptorSetLayoutDeleter - { - public: - DescriptorSetLayoutDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( DescriptorSetLayout descriptorSetLayout ) - { - m_device.destroyDescriptorSetLayout( descriptorSetLayout, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class DescriptorUpdateTemplateKHRDeleter - { - public: - DescriptorUpdateTemplateKHRDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( DescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR ) - { - m_device.destroyDescriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class DeviceMemoryDeleter - { - public: - DeviceMemoryDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( DeviceMemory deviceMemory ) - { - m_device.freeMemory( deviceMemory, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class EventDeleter - { - public: - EventDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Event event ) - { - m_device.destroyEvent( event, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class FenceDeleter - { - public: - FenceDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Fence fence ) - { - m_device.destroyFence( fence, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class FramebufferDeleter - { - public: - FramebufferDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Framebuffer framebuffer ) - { - m_device.destroyFramebuffer( framebuffer, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class ImageDeleter - { - public: - ImageDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Image image ) - { - m_device.destroyImage( image, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class ImageViewDeleter - { - public: - ImageViewDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( ImageView imageView ) - { - m_device.destroyImageView( imageView, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class IndirectCommandsLayoutNVXDeleter - { - public: - IndirectCommandsLayoutNVXDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( IndirectCommandsLayoutNVX indirectCommandsLayoutNVX ) - { - m_device.destroyIndirectCommandsLayoutNVX( indirectCommandsLayoutNVX, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class ObjectTableNVXDeleter - { - public: - ObjectTableNVXDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( ObjectTableNVX objectTableNVX ) - { - m_device.destroyObjectTableNVX( objectTableNVX, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class PipelineDeleter - { - public: - PipelineDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Pipeline pipeline ) - { - m_device.destroyPipeline( pipeline, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class PipelineCacheDeleter - { - public: - PipelineCacheDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( PipelineCache pipelineCache ) - { - m_device.destroyPipelineCache( pipelineCache, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class PipelineLayoutDeleter - { - public: - PipelineLayoutDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( PipelineLayout pipelineLayout ) - { - m_device.destroyPipelineLayout( pipelineLayout, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class QueryPoolDeleter - { - public: - QueryPoolDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( QueryPool queryPool ) - { - m_device.destroyQueryPool( queryPool, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class RenderPassDeleter - { - public: - RenderPassDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( RenderPass renderPass ) - { - m_device.destroyRenderPass( renderPass, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class SamplerDeleter - { - public: - SamplerDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Sampler sampler ) - { - m_device.destroySampler( sampler, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class SamplerYcbcrConversionKHRDeleter - { - public: - SamplerYcbcrConversionKHRDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( SamplerYcbcrConversionKHR samplerYcbcrConversionKHR ) - { - m_device.destroySamplerYcbcrConversionKHR( samplerYcbcrConversionKHR, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class SemaphoreDeleter - { - public: - SemaphoreDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Semaphore semaphore ) - { - m_device.destroySemaphore( semaphore, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class ShaderModuleDeleter - { - public: - ShaderModuleDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( ShaderModule shaderModule ) - { - m_device.destroyShaderModule( shaderModule, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class SwapchainKHRDeleter - { - public: - SwapchainKHRDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( SwapchainKHR swapchainKHR ) - { - m_device.destroySwapchainKHR( swapchainKHR, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; - - class ValidationCacheEXTDeleter - { - public: - ValidationCacheEXTDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_device( device ) - , m_allocator( allocator ) - {} - - Device getDevice() const { return m_device; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( ValidationCacheEXT validationCacheEXT ) - { - m_device.destroyValidationCacheEXT( validationCacheEXT, m_allocator ); - } - - private: - Device m_device; - Optional<const AllocationCallbacks> m_allocator; - }; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char* pName ) const - { - return vkGetDeviceProcAddr( m_device, pName ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name ) const - { - return vkGetDeviceProcAddr( m_device, name.c_str() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator ) const - { - vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue ) const - { - vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const - { - Queue queue; - vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) ); - return queue; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::waitIdle() const - { - return static_cast<Result>( vkDeviceWaitIdle( m_device ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Device::waitIdle() const - { - Result result = static_cast<Result>( vkDeviceWaitIdle( m_device ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::waitIdle" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory ) const - { - return static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( pAllocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDeviceMemory*>( pMemory ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DeviceMemory>::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator ) const - { - DeviceMemory memory; - Result result = static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) ); - return createResultValue( result, memory, "VULKAN_HPP_NAMESPACE::Device::allocateMemory" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueDeviceMemory>::type Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator ) const - { - DeviceMemory memory; - Result result = static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) ); - - DeviceMemoryDeleter deleter( *this, allocator ); - return createResultValue( result, memory, "VULKAN_HPP_NAMESPACE::Device::allocateMemoryUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator ) const - { - vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator ) const - { - vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData ) const - { - return static_cast<Result>( vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), ppData ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags ) const - { - void* pData; - Result result = static_cast<Result>( vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), &pData ) ); - return createResultValue( result, pData, "VULKAN_HPP_NAMESPACE::Device::mapMemory" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory ) const - { - vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) ); - } - - VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const - { - return static_cast<Result>( vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const - { - Result result = static_cast<Result>( vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::flushMappedMemoryRanges" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const - { - return static_cast<Result>( vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const - { - Result result = static_cast<Result>( vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::invalidateMappedMemoryRanges" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes ) const - { - vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), pCommittedMemoryInBytes ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory ) const - { - DeviceSize committedMemoryInBytes; - vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), &committedMemoryInBytes ); - return committedMemoryInBytes; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements ) const - { - vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer ) const - { - MemoryRequirements memoryRequirements; - vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) ); - return memoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const - { - return static_cast<Result>( vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const - { - Result result = static_cast<Result>( vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindBufferMemory" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements ) const - { - vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image ) const - { - MemoryRequirements memoryRequirements; - vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) ); - return memoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const - { - return static_cast<Result>( vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const - { - Result result = static_cast<Result>( vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindImageMemory" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements ) const - { - vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image ) const - { - std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) ); - return sparseMemoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const - { - return static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Fence fence; - Result result = static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) ); - return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::createFence" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueFence>::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Fence fence; - Result result = static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) ); - - FenceDeleter deleter( *this, allocator ); - return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::createFenceUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator ) const - { - vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences ) const - { - return static_cast<Result>( vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> fences ) const - { - Result result = static_cast<Result>( vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetFences" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence ) const - { - return static_cast<Result>( vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) ); - } -#else - VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence ) const - { - Result result = static_cast<Result>( vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout ) const - { - return static_cast<Result>( vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), waitAll, timeout ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout ) const - { - Result result = static_cast<Result>( vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), waitAll, timeout ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore ) const - { - return static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Semaphore semaphore; - Result result = static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) ); - return createResultValue( result, semaphore, "VULKAN_HPP_NAMESPACE::Device::createSemaphore" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSemaphore>::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Semaphore semaphore; - Result result = static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) ); - - SemaphoreDeleter deleter( *this, allocator ); - return createResultValue( result, semaphore, "VULKAN_HPP_NAMESPACE::Device::createSemaphoreUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator ) const - { - vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent ) const - { - return static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Event event; - Result result = static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) ); - return createResultValue( result, event, "VULKAN_HPP_NAMESPACE::Device::createEvent" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueEvent>::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Event event; - Result result = static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) ); - - EventDeleter deleter( *this, allocator ); - return createResultValue( result, event, "VULKAN_HPP_NAMESPACE::Device::createEventUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator ) const - { - vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::getEventStatus( Event event ) const - { - return static_cast<Result>( vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) ); - } -#else - VULKAN_HPP_INLINE Result Device::getEventStatus( Event event ) const - { - Result result = static_cast<Result>( vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::setEvent( Event event ) const - { - return static_cast<Result>( vkSetEvent( m_device, static_cast<VkEvent>( event ) ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( Event event ) const - { - Result result = static_cast<Result>( vkSetEvent( m_device, static_cast<VkEvent>( event ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::setEvent" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::resetEvent( Event event ) const - { - return static_cast<Result>( vkResetEvent( m_device, static_cast<VkEvent>( event ) ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( Event event ) const - { - Result result = static_cast<Result>( vkResetEvent( m_device, static_cast<VkEvent>( event ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetEvent" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool ) const - { - return static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - QueryPool queryPool; - Result result = static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) ); - return createResultValue( result, queryPool, "VULKAN_HPP_NAMESPACE::Device::createQueryPool" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueQueryPool>::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - QueryPool queryPool; - Result result = static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) ); - - QueryPoolDeleter deleter( *this, allocator ); - return createResultValue( result, queryPool, "VULKAN_HPP_NAMESPACE::Device::createQueryPoolUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator ) const - { - vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags ) const - { - return static_cast<Result>( vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast<VkQueryResultFlags>( flags ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename T> - VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags ) const - { - Result result = static_cast<Result>( vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), stride, static_cast<VkQueryResultFlags>( flags ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer ) const - { - return static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Buffer buffer; - Result result = static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) ); - return createResultValue( result, buffer, "VULKAN_HPP_NAMESPACE::Device::createBuffer" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueBuffer>::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Buffer buffer; - Result result = static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) ); - - BufferDeleter deleter( *this, allocator ); - return createResultValue( result, buffer, "VULKAN_HPP_NAMESPACE::Device::createBufferUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator ) const - { - vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView ) const - { - return static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - BufferView view; - Result result = static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) ); - return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createBufferView" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueBufferView>::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - BufferView view; - Result result = static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) ); - - BufferViewDeleter deleter( *this, allocator ); - return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createBufferViewUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator ) const - { - vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage ) const - { - return static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Image image; - Result result = static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) ); - return createResultValue( result, image, "VULKAN_HPP_NAMESPACE::Device::createImage" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueImage>::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Image image; - Result result = static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) ); - - ImageDeleter deleter( *this, allocator ); - return createResultValue( result, image, "VULKAN_HPP_NAMESPACE::Device::createImageUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator ) const - { - vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout ) const - { - vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource ) const - { - SubresourceLayout layout; - vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) ); - return layout; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView ) const - { - return static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ImageView view; - Result result = static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) ); - return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createImageView" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueImageView>::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ImageView view; - Result result = static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) ); - - ImageViewDeleter deleter( *this, allocator ); - return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createImageViewUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator ) const - { - vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule ) const - { - return static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ShaderModule shaderModule; - Result result = static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) ); - return createResultValue( result, shaderModule, "VULKAN_HPP_NAMESPACE::Device::createShaderModule" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueShaderModule>::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ShaderModule shaderModule; - Result result = static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) ); - - ShaderModuleDeleter deleter( *this, allocator ); - return createResultValue( result, shaderModule, "VULKAN_HPP_NAMESPACE::Device::createShaderModuleUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator ) const - { - vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache ) const - { - return static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - PipelineCache pipelineCache; - Result result = static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) ); - return createResultValue( result, pipelineCache, "VULKAN_HPP_NAMESPACE::Device::createPipelineCache" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniquePipelineCache>::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - PipelineCache pipelineCache; - Result result = static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) ); - - PipelineCacheDeleter deleter( *this, allocator ); - return createResultValue( result, pipelineCache, "VULKAN_HPP_NAMESPACE::Device::createPipelineCacheUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator ) const - { - vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData ) const - { - return static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache ) const - { - std::vector<uint8_t,Allocator> data; - size_t dataSize; - Result result; - do - { - result = static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( dataSize <= data.size() ); - data.resize( dataSize ); - return createResultValue( result, data, "VULKAN_HPP_NAMESPACE::Device::getPipelineCacheData" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches ) const - { - return static_cast<Result>( vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches ) const - { - Result result = static_cast<Result>( vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::mergePipelineCaches" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const - { - return static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const - { - std::vector<Pipeline,Allocator> pipelines( createInfos.size() ); - Result result = static_cast<Result>( 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() ) ) ); - return createResultValue( result, pipelines, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelines" ); - } - VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Pipeline pipeline; - Result result = static_cast<Result>( 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 ) ) ); - return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipeline" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const - { - std::vector<Pipeline,Allocator> pipelines( createInfos.size() ); - Result result = static_cast<Result>( 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() ) ) ); - - PipelineDeleter deleter( *this, allocator ); - std::vector<UniquePipeline> uniquePipelines; - uniquePipelines.reserve( pipelines.size() ); - for ( auto const& pipeline : pipelines ) - { - uniquePipelines.push_back( UniquePipeline( pipeline, deleter ) ); - } - - return createResultValue( result, uniquePipelines, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelinesUnique" ); - } - VULKAN_HPP_INLINE ResultValueType<UniquePipeline>::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Pipeline pipeline; - Result result = static_cast<Result>( 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 ) ) ); - - PipelineDeleter deleter( *this, allocator ); - return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelineUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const - { - return static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const - { - std::vector<Pipeline,Allocator> pipelines( createInfos.size() ); - Result result = static_cast<Result>( 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() ) ) ); - return createResultValue( result, pipelines, "VULKAN_HPP_NAMESPACE::Device::createComputePipelines" ); - } - VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Pipeline pipeline; - Result result = static_cast<Result>( 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 ) ) ); - return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createComputePipeline" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const - { - std::vector<Pipeline,Allocator> pipelines( createInfos.size() ); - Result result = static_cast<Result>( 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() ) ) ); - - PipelineDeleter deleter( *this, allocator ); - std::vector<UniquePipeline> uniquePipelines; - uniquePipelines.reserve( pipelines.size() ); - for ( auto const& pipeline : pipelines ) - { - uniquePipelines.push_back( UniquePipeline( pipeline, deleter ) ); - } - - return createResultValue( result, uniquePipelines, "VULKAN_HPP_NAMESPACE::Device::createComputePipelinesUnique" ); - } - VULKAN_HPP_INLINE ResultValueType<UniquePipeline>::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Pipeline pipeline; - Result result = static_cast<Result>( 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 ) ) ); - - PipelineDeleter deleter( *this, allocator ); - return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createComputePipelineUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator ) const - { - vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout ) const - { - return static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - PipelineLayout pipelineLayout; - Result result = static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) ); - return createResultValue( result, pipelineLayout, "VULKAN_HPP_NAMESPACE::Device::createPipelineLayout" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniquePipelineLayout>::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - PipelineLayout pipelineLayout; - Result result = static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) ); - - PipelineLayoutDeleter deleter( *this, allocator ); - return createResultValue( result, pipelineLayout, "VULKAN_HPP_NAMESPACE::Device::createPipelineLayoutUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator ) const - { - vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler ) const - { - return static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Sampler sampler; - Result result = static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) ); - return createResultValue( result, sampler, "VULKAN_HPP_NAMESPACE::Device::createSampler" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSampler>::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Sampler sampler; - Result result = static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) ); - - SamplerDeleter deleter( *this, allocator ); - return createResultValue( result, sampler, "VULKAN_HPP_NAMESPACE::Device::createSamplerUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator ) const - { - vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout ) const - { - return static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DescriptorSetLayout setLayout; - Result result = static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) ); - return createResultValue( result, setLayout, "VULKAN_HPP_NAMESPACE::Device::createDescriptorSetLayout" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueDescriptorSetLayout>::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DescriptorSetLayout setLayout; - Result result = static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) ); - - DescriptorSetLayoutDeleter deleter( *this, allocator ); - return createResultValue( result, setLayout, "VULKAN_HPP_NAMESPACE::Device::createDescriptorSetLayoutUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator ) const - { - vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool ) const - { - return static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DescriptorPool descriptorPool; - Result result = static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) ); - return createResultValue( result, descriptorPool, "VULKAN_HPP_NAMESPACE::Device::createDescriptorPool" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueDescriptorPool>::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DescriptorPool descriptorPool; - Result result = static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) ); - - DescriptorPoolDeleter deleter( *this, allocator ); - return createResultValue( result, descriptorPool, "VULKAN_HPP_NAMESPACE::Device::createDescriptorPoolUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator ) const - { - vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) const - { - return static_cast<Result>( vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) const - { - Result result = static_cast<Result>( vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetDescriptorPool" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets ) const - { - return static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo ) const - { - std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) ); - return createResultValue( result, descriptorSets, "VULKAN_HPP_NAMESPACE::Device::allocateDescriptorSets" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueDescriptorSet,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo ) const - { - std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) ); - - DescriptorSetDeleter deleter( *this, allocateInfo.descriptorPool ); - std::vector<UniqueDescriptorSet> uniqueDescriptorSets; - uniqueDescriptorSets.reserve( descriptorSets.size() ); - for ( auto const& descriptorSet : descriptorSets ) - { - uniqueDescriptorSets.push_back( UniqueDescriptorSet( descriptorSet, deleter ) ); - } - - return createResultValue( result, uniqueDescriptorSets, "VULKAN_HPP_NAMESPACE::Device::allocateDescriptorSetsUnique" ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets ) const - { - return static_cast<Result>( vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets ) const - { - Result result = static_cast<Result>( vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::freeDescriptorSets" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies ) const - { - vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies ) const - { - vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer ) const - { - return static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Framebuffer framebuffer; - Result result = static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) ); - return createResultValue( result, framebuffer, "VULKAN_HPP_NAMESPACE::Device::createFramebuffer" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueFramebuffer>::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Framebuffer framebuffer; - Result result = static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) ); - - FramebufferDeleter deleter( *this, allocator ); - return createResultValue( result, framebuffer, "VULKAN_HPP_NAMESPACE::Device::createFramebufferUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator ) const - { - vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass ) const - { - return static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - RenderPass renderPass; - Result result = static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) ); - return createResultValue( result, renderPass, "VULKAN_HPP_NAMESPACE::Device::createRenderPass" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueRenderPass>::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - RenderPass renderPass; - Result result = static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) ); - - RenderPassDeleter deleter( *this, allocator ); - return createResultValue( result, renderPass, "VULKAN_HPP_NAMESPACE::Device::createRenderPassUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator ) const - { - vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity ) const - { - vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass ) const - { - Extent2D granularity; - vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) ); - return granularity; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool ) const - { - return static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - CommandPool commandPool; - Result result = static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) ); - return createResultValue( result, commandPool, "VULKAN_HPP_NAMESPACE::Device::createCommandPool" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueCommandPool>::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - CommandPool commandPool; - Result result = static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) ); - - CommandPoolDeleter deleter( *this, allocator ); - return createResultValue( result, commandPool, "VULKAN_HPP_NAMESPACE::Device::createCommandPoolUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator ) const - { - vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const - { - return static_cast<Result>( vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const - { - Result result = static_cast<Result>( vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetCommandPool" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers ) const - { - return static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo ) const - { - std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) ); - return createResultValue( result, commandBuffers, "VULKAN_HPP_NAMESPACE::Device::allocateCommandBuffers" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueCommandBuffer,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo ) const - { - std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) ); - - CommandBufferDeleter deleter( *this, allocateInfo.commandPool ); - std::vector<UniqueCommandBuffer> uniqueCommandBuffers; - uniqueCommandBuffers.reserve( commandBuffers.size() ); - for ( auto const& commandBuffer : commandBuffers ) - { - uniqueCommandBuffers.push_back( UniqueCommandBuffer( commandBuffer, deleter ) ); - } - - return createResultValue( result, uniqueCommandBuffers, "VULKAN_HPP_NAMESPACE::Device::allocateCommandBuffersUnique" ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const - { - vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers ) const - { - vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains ) const - { - return static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator ) const - { - std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() ); - Result result = static_cast<Result>( 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() ) ) ); - return createResultValue( result, swapchains, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainsKHR" ); - } - VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SwapchainKHR swapchain; - Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) ); - return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueSwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator ) const - { - std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() ); - Result result = static_cast<Result>( 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() ) ) ); - - SwapchainKHRDeleter deleter( *this, allocator ); - std::vector<UniqueSwapchainKHR> uniqueSwapchains; - uniqueSwapchains.reserve( swapchains.size() ); - for ( auto const& swapchain : swapchains ) - { - uniqueSwapchains.push_back( UniqueSwapchainKHR( swapchain, deleter ) ); - } - - return createResultValue( result, uniqueSwapchains, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainsKHRUnique" ); - } - VULKAN_HPP_INLINE ResultValueType<UniqueSwapchainKHR>::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SwapchainKHR swapchain; - Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) ); - - SwapchainKHRDeleter deleter( *this, allocator ); - return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain ) const - { - return static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SwapchainKHR swapchain; - Result result = static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) ); - return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSwapchainKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSwapchainKHR>::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SwapchainKHR swapchain; - Result result = static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) ); - - SwapchainKHRDeleter deleter( *this, allocator ); - return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSwapchainKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator ) const - { - vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages ) const - { - return static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain ) const - { - std::vector<Image,Allocator> swapchainImages; - uint32_t swapchainImageCount; - Result result; - do - { - result = static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && swapchainImageCount ) - { - swapchainImages.resize( swapchainImageCount ); - result = static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( swapchainImageCount <= swapchainImages.size() ); - swapchainImages.resize( swapchainImageCount ); - return createResultValue( result, swapchainImages, "VULKAN_HPP_NAMESPACE::Device::getSwapchainImagesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex ) const - { - return static_cast<Result>( vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence ) const - { - uint32_t imageIndex; - Result result = static_cast<Result>( vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) ); - return createResultValue( result, imageIndex, "VULKAN_HPP_NAMESPACE::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo ) const - { - return static_cast<Result>( vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const - { - Result result = static_cast<Result>( vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( &nameInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::debugMarkerSetObjectNameEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo ) const - { - return static_cast<Result>( vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const - { - Result result = static_cast<Result>( vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( &tagInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::debugMarkerSetObjectTagEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const - { - return static_cast<Result>( vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType ) const - { - HANDLE handle; - Result result = static_cast<Result>( vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) ); - return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getMemoryWin32HandleNV" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const - { - return static_cast<Result>( vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( pIndirectCommandsLayout ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - IndirectCommandsLayoutNVX indirectCommandsLayout; - Result result = static_cast<Result>( vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) ); - return createResultValue( result, indirectCommandsLayout, "VULKAN_HPP_NAMESPACE::Device::createIndirectCommandsLayoutNVX" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueIndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - IndirectCommandsLayoutNVX indirectCommandsLayout; - Result result = static_cast<Result>( vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) ); - - IndirectCommandsLayoutNVXDeleter deleter( *this, allocator ); - return createResultValue( result, indirectCommandsLayout, "VULKAN_HPP_NAMESPACE::Device::createIndirectCommandsLayoutNVXUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator ) const - { - vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable ) const - { - return static_cast<Result>( vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkObjectTableNVX*>( pObjectTable ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ObjectTableNVX objectTable; - Result result = static_cast<Result>( vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) ); - return createResultValue( result, objectTable, "VULKAN_HPP_NAMESPACE::Device::createObjectTableNVX" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueObjectTableNVX>::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ObjectTableNVX objectTable; - Result result = static_cast<Result>( vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) ); - - ObjectTableNVXDeleter deleter( *this, allocator ); - return createResultValue( result, objectTable, "VULKAN_HPP_NAMESPACE::Device::createObjectTableNVXUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator ) const - { - vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const - { - return static_cast<Result>( vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectTableEntryNVX* const*>( ppObjectTableEntries ), pObjectIndices ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( pObjectTableEntries.size() == objectIndices.size() ); -#else - if ( pObjectTableEntries.size() != objectIndices.size() ) - { - throw LogicError( "VULKAN_HPP_NAMESPACE::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - Result result = static_cast<Result>( vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), pObjectTableEntries.size() , reinterpret_cast<const VkObjectTableEntryNVX* const*>( pObjectTableEntries.data() ), objectIndices.data() ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::registerObjectsNVX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const - { - return static_cast<Result>( vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectEntryTypeNVX*>( pObjectEntryTypes ), pObjectIndices ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( objectEntryTypes.size() == objectIndices.size() ); -#else - if ( objectEntryTypes.size() != objectIndices.size() ) - { - throw LogicError( "VULKAN_HPP_NAMESPACE::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - Result result = static_cast<Result>( vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectEntryTypes.size() , reinterpret_cast<const VkObjectEntryTypeNVX*>( objectEntryTypes.data() ), objectIndices.data() ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::unregisterObjectsNVX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags ) const - { - vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlagsKHR>( flags ) ); - } - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const - { - return static_cast<Result>( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const - { - HANDLE handle; - Result result = static_cast<Result>( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getMemoryWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const - { - return static_cast<Result>( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( pMemoryWin32HandleProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const - { - MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; - Result result = static_cast<Result>( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( &memoryWin32HandleProperties ) ) ); - return createResultValue( result, memoryWin32HandleProperties, "VULKAN_HPP_NAMESPACE::Device::getMemoryWin32HandlePropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const - { - return static_cast<Result>( vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( pGetFdInfo ), pFd ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<int>::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const - { - int fd; - Result result = static_cast<Result>( vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, "VULKAN_HPP_NAMESPACE::Device::getMemoryFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const - { - return static_cast<Result>( vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( pMemoryFdProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const - { - MemoryFdPropertiesKHR memoryFdProperties; - Result result = static_cast<Result>( vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( &memoryFdProperties ) ) ); - return createResultValue( result, memoryFdProperties, "VULKAN_HPP_NAMESPACE::Device::getMemoryFdPropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const - { - return static_cast<Result>( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const - { - HANDLE handle; - Result result = static_cast<Result>( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getSemaphoreWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const - { - return static_cast<Result>( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( pImportSemaphoreWin32HandleInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const - { - Result result = static_cast<Result>( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( &importSemaphoreWin32HandleInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importSemaphoreWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const - { - return static_cast<Result>( vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( pGetFdInfo ), pFd ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<int>::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const - { - int fd; - Result result = static_cast<Result>( vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, "VULKAN_HPP_NAMESPACE::Device::getSemaphoreFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const - { - return static_cast<Result>( vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( pImportSemaphoreFdInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const - { - Result result = static_cast<Result>( vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( &importSemaphoreFdInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importSemaphoreFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const - { - return static_cast<Result>( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const - { - HANDLE handle; - Result result = static_cast<Result>( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getFenceWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const - { - return static_cast<Result>( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( pImportFenceWin32HandleInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const - { - Result result = static_cast<Result>( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( &importFenceWin32HandleInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importFenceWin32HandleKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const - { - return static_cast<Result>( vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( pGetFdInfo ), pFd ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<int>::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const - { - int fd; - Result result = static_cast<Result>( vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, "VULKAN_HPP_NAMESPACE::Device::getFenceFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const - { - return static_cast<Result>( vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( pImportFenceFdInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const - { - Result result = static_cast<Result>( vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( &importFenceFdInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importFenceFdKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const - { - return static_cast<Result>( vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo ) const - { - Result result = static_cast<Result>( vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( &displayPowerInfo ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::displayPowerControlEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const - { - return static_cast<Result>( vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( pDeviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator ) const - { - Fence fence; - Result result = static_cast<Result>( vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) ); - return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::registerEventEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const - { - return static_cast<Result>( vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator ) const - { - Fence fence; - Result result = static_cast<Result>( 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 ) ) ); - return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::registerDisplayEventEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const - { - return static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValue<uint64_t> Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter ) const - { - uint64_t counterValue; - Result result = static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) ); - return createResultValue( result, counterValue, "VULKAN_HPP_NAMESPACE::Device::getSwapchainCounterEXT", { Result::eSuccess, Result::eErrorDeviceLost, Result::eErrorOutOfDateKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures ) const - { - vkGetDeviceGroupPeerMemoryFeaturesKHX( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlagsKHX*>( pPeerMemoryFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX Device::getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const - { - PeerMemoryFeatureFlagsKHX peerMemoryFeatures; - vkGetDeviceGroupPeerMemoryFeaturesKHX( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlagsKHX*>( &peerMemoryFeatures ) ); - return peerMemoryFeatures; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfoKHR* pBindInfos ) const - { - return static_cast<Result>( vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfoKHR*>( pBindInfos ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfoKHR> bindInfos ) const - { - Result result = static_cast<Result>( vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfoKHR*>( bindInfos.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindBufferMemory2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfoKHR* pBindInfos ) const - { - return static_cast<Result>( vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfoKHR*>( pBindInfos ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfoKHR> bindInfos ) const - { - Result result = static_cast<Result>( vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfoKHR*>( bindInfos.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindImageMemory2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHX( DeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities ) const - { - return static_cast<Result>( vkGetDeviceGroupPresentCapabilitiesKHX( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX*>( pDeviceGroupPresentCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentCapabilitiesKHX>::type Device::getGroupPresentCapabilitiesKHX() const - { - DeviceGroupPresentCapabilitiesKHX deviceGroupPresentCapabilities; - Result result = static_cast<Result>( vkGetDeviceGroupPresentCapabilitiesKHX( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX*>( &deviceGroupPresentCapabilities ) ) ); - return createResultValue( result, deviceGroupPresentCapabilities, "VULKAN_HPP_NAMESPACE::Device::getGroupPresentCapabilitiesKHX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHX( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHX* pModes ) const - { - return static_cast<Result>( vkGetDeviceGroupSurfacePresentModesKHX( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHX*>( pModes ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHX>::type Device::getGroupSurfacePresentModesKHX( SurfaceKHR surface ) const - { - DeviceGroupPresentModeFlagsKHX modes; - Result result = static_cast<Result>( vkGetDeviceGroupSurfacePresentModesKHX( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHX*>( &modes ) ) ); - return createResultValue( result, modes, "VULKAN_HPP_NAMESPACE::Device::getGroupSurfacePresentModesKHX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::acquireNextImage2KHX( const AcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex ) const - { - return static_cast<Result>( vkAcquireNextImage2KHX( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHX*>( pAcquireInfo ), pImageIndex ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHX( const AcquireNextImageInfoKHX & acquireInfo ) const - { - uint32_t imageIndex; - Result result = static_cast<Result>( vkAcquireNextImage2KHX( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHX*>( &acquireInfo ), &imageIndex ) ); - return createResultValue( result, imageIndex, "VULKAN_HPP_NAMESPACE::Device::acquireNextImage2KHX", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate ) const - { - return static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( pDescriptorUpdateTemplate ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DescriptorUpdateTemplateKHR>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DescriptorUpdateTemplateKHR descriptorUpdateTemplate; - Result result = static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( &descriptorUpdateTemplate ) ) ); - return createResultValue( result, descriptorUpdateTemplate, "VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplateKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueDescriptorUpdateTemplateKHR>::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DescriptorUpdateTemplateKHR descriptorUpdateTemplate; - Result result = static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( &descriptorUpdateTemplate ) ) ); - - DescriptorUpdateTemplateKHRDeleter deleter( *this, allocator ); - return createResultValue( result, descriptorUpdateTemplate, "VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplateKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const AllocationCallbacks* pAllocator ) const - { - vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData ) const - { - vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), pData ); - } - - VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata ) const - { - vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR*>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT*>( pMetadata ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( swapchains.size() == metadata.size() ); -#else - if ( swapchains.size() != metadata.size() ) - { - throw LogicError( "VULKAN_HPP_NAMESPACE::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast<const VkSwapchainKHR*>( swapchains.data() ), reinterpret_cast<const VkHdrMetadataEXT*>( metadata.data() ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain ) const - { - return static_cast<Result>( vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); - } -#else - VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain ) const - { - Result result = static_cast<Result>( vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const - { - return static_cast<Result>( vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( pDisplayTimingProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain ) const - { - RefreshCycleDurationGOOGLE displayTimingProperties; - Result result = static_cast<Result>( vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( &displayTimingProperties ) ) ); - return createResultValue( result, displayTimingProperties, "VULKAN_HPP_NAMESPACE::Device::getRefreshCycleDurationGOOGLE" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings ) const - { - return static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), pPresentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( pPresentationTimings ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const - { - std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings; - uint32_t presentationTimingCount; - Result result; - do - { - result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentationTimingCount ) - { - presentationTimings.resize( presentationTimingCount ); - result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( presentationTimingCount <= presentationTimings.size() ); - presentationTimings.resize( presentationTimingCount ); - return createResultValue( result, presentationTimings, "VULKAN_HPP_NAMESPACE::Device::getPastPresentationTimingGOOGLE" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const - { - vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const - { - MemoryRequirements2KHR memoryRequirements; - vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) ); - return memoryRequirements; - } - template <typename ...T> - VULKAN_HPP_INLINE StructureChain<T...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const - { - StructureChain<T...> structureChain; - MemoryRequirements2KHR& memoryRequirements = structureChain.template get<MemoryRequirements2KHR>(); - vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const - { - vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const - { - MemoryRequirements2KHR memoryRequirements; - vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) ); - return memoryRequirements; - } - template <typename ...T> - VULKAN_HPP_INLINE StructureChain<T...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const - { - StructureChain<T...> structureChain; - MemoryRequirements2KHR& memoryRequirements = structureChain.template get<MemoryRequirements2KHR>(); - vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const - { - vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2KHR*>( pSparseMemoryRequirements ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2KHR,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const - { - std::vector<SparseImageMemoryRequirements2KHR,Allocator> sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2KHR*>( sparseMemoryRequirements.data() ) ); - return sparseMemoryRequirements; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversionKHR* pYcbcrConversion ) const - { - return static_cast<Result>( vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversionKHR*>( pYcbcrConversion ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SamplerYcbcrConversionKHR>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SamplerYcbcrConversionKHR ycbcrConversion; - Result result = static_cast<Result>( vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversionKHR*>( &ycbcrConversion ) ) ); - return createResultValue( result, ycbcrConversion, "VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversionKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSamplerYcbcrConversionKHR>::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SamplerYcbcrConversionKHR ycbcrConversion; - Result result = static_cast<Result>( vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversionKHR*>( &ycbcrConversion ) ) ); - - SamplerYcbcrConversionKHRDeleter deleter( *this, allocator ); - return createResultValue( result, ycbcrConversion, "VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversionKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, const AllocationCallbacks* pAllocator ) const - { - vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversionKHR>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversionKHR>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache ) const - { - return static_cast<Result>( vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkValidationCacheEXT*>( pValidationCache ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ValidationCacheEXT validationCache; - Result result = static_cast<Result>( vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) ); - return createResultValue( result, validationCache, "VULKAN_HPP_NAMESPACE::Device::createValidationCacheEXT" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueValidationCacheEXT>::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - ValidationCacheEXT validationCache; - Result result = static_cast<Result>( vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) ); - - ValidationCacheEXTDeleter deleter( *this, allocator ); - return createResultValue( result, validationCache, "VULKAN_HPP_NAMESPACE::Device::createValidationCacheEXTUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator ) const - { - vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const - { - return static_cast<Result>( vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache ) const - { - std::vector<uint8_t,Allocator> data; - size_t dataSize; - Result result; - do - { - result = static_cast<Result>( vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast<Result>( vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( dataSize <= data.size() ); - data.resize( dataSize ); - return createResultValue( result, data, "VULKAN_HPP_NAMESPACE::Device::getValidationCacheDataEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches ) const - { - return static_cast<Result>( vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT*>( pSrcCaches ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches ) const - { - Result result = static_cast<Result>( vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size() , reinterpret_cast<const VkValidationCacheEXT*>( srcCaches.data() ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::mergeValidationCachesEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const - { - return static_cast<Result>( vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), pInfoSize, pInfo ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const - { - std::vector<uint8_t,Allocator> info; - size_t infoSize; - Result result; - do - { - result = static_cast<Result>( vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && infoSize ) - { - info.resize( infoSize ); - result = static_cast<Result>( vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, reinterpret_cast<void*>( info.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( infoSize <= info.size() ); - info.resize( infoSize ); - return createResultValue( result, info, "VULKAN_HPP_NAMESPACE::Device::getShaderInfoAMD" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const - { - return static_cast<Result>( vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer ) const - { - MemoryHostPointerPropertiesEXT memoryHostPointerProperties; - Result result = static_cast<Result>( vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) ); - return createResultValue( result, memoryHostPointerProperties, "VULKAN_HPP_NAMESPACE::Device::getMemoryHostPointerPropertiesEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class DeviceDeleter; - template <> class UniqueHandleTraits<Device> {public: using deleter = DeviceDeleter; }; - using UniqueDevice = UniqueHandle<Device>; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - class PhysicalDevice - { - public: - PhysicalDevice() - : m_physicalDevice(VK_NULL_HANDLE) - {} - - PhysicalDevice( std::nullptr_t ) - : m_physicalDevice(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) - : m_physicalDevice( physicalDevice ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) - { - m_physicalDevice = physicalDevice; - return *this; - } -#endif - - PhysicalDevice & operator=( std::nullptr_t ) - { - m_physicalDevice = VK_NULL_HANDLE; - return *this; - } - - bool operator==( PhysicalDevice const & rhs ) const - { - return m_physicalDevice == rhs.m_physicalDevice; - } - - bool operator!=(PhysicalDevice const & rhs ) const - { - return m_physicalDevice != rhs.m_physicalDevice; - } - - bool operator<(PhysicalDevice const & rhs ) const - { - return m_physicalDevice < rhs.m_physicalDevice; - } - - void getProperties( PhysicalDeviceProperties* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PhysicalDeviceProperties getProperties() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<QueueFamilyProperties>> - std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PhysicalDeviceMemoryProperties getMemoryProperties() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getFeatures( PhysicalDeviceFeatures* pFeatures ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PhysicalDeviceFeatures getFeatures() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getFormatProperties( Format format, FormatProperties* pFormatProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - FormatProperties getFormatProperties( Format format ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<ImageFormatProperties>::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueDevice>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<LayerProperties>> - typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<ExtensionProperties>> - typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<SparseImageFormatProperties>> - std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<DisplayPropertiesKHR>> - typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>> - typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<DisplayKHR>> - typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<DisplayModePropertiesKHR>> - typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( SurfaceKHR surface ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<SurfaceFormatKHR>> - typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<PresentModeKHR>> - typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getFeatures2KHR( PhysicalDeviceFeatures2KHR* pFeatures ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PhysicalDeviceFeatures2KHR getFeatures2KHR() const; - template <typename ...T> - StructureChain<T...> getFeatures2KHR() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getProperties2KHR( PhysicalDeviceProperties2KHR* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PhysicalDeviceProperties2KHR getProperties2KHR() const; - template <typename ...T> - StructureChain<T...> getProperties2KHR() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getFormatProperties2KHR( Format format, FormatProperties2KHR* pFormatProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - FormatProperties2KHR getFormatProperties2KHR( Format format ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, ImageFormatProperties2KHR* pImageFormatProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<ImageFormatProperties2KHR>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const; - template <typename ...T> - typename ResultValueType<StructureChain<T...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2KHR* pQueueFamilyProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<QueueFamilyProperties2KHR>> - std::vector<QueueFamilyProperties2KHR,Allocator> getQueueFamilyProperties2KHR() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2KHR* pMemoryProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PhysicalDeviceMemoryProperties2KHR getMemoryProperties2KHR() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2KHR* pProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<SparseImageFormatProperties2KHR>> - std::vector<SparseImageFormatProperties2KHR,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ExternalBufferPropertiesKHR getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ExternalSemaphorePropertiesKHR getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ExternalFencePropertiesKHR getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - Result releaseDisplayEXT( DisplayKHR display ) const; -#else - ResultValueType<void>::type releaseDisplayEXT( DisplayKHR display ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT - Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Display>::type acquireXlibDisplayEXT( DisplayKHR display ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT - Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( SurfaceKHR surface ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getPresentRectanglesKHX( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<Rect2D>> - typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHX( SurfaceKHR surface ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; - template <typename ...T> - typename ResultValueType<StructureChain<T...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<SurfaceFormat2KHR>> - typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const - { - return m_physicalDevice; - } - - explicit operator bool() const - { - return m_physicalDevice != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_physicalDevice == VK_NULL_HANDLE; - } - - private: - VkPhysicalDevice m_physicalDevice; - }; - - static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class DeviceDeleter - { - public: - DeviceDeleter( Optional<const AllocationCallbacks> allocator = nullptr ) - : m_allocator( allocator ) - {} - - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Device device ) - { - device.destroy( m_allocator ); - } - - private: - Optional<const AllocationCallbacks> m_allocator; - }; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties ) const - { - vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties() const - { - PhysicalDeviceProperties properties; - vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) ); - return properties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties ) const - { - vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties() const - { - std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) ); - return queueFamilyProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties ) const - { - vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const - { - PhysicalDeviceMemoryProperties memoryProperties; - vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) ); - return memoryProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures ) const - { - vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures() const - { - PhysicalDeviceFeatures features; - vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) ); - return features; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties ) const - { - vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format ) const - { - FormatProperties formatProperties; - vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) ); - return formatProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties ) const - { - return static_cast<Result>( 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 ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags ) const - { - ImageFormatProperties imageFormatProperties; - Result result = static_cast<Result>( 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 ) ) ); - return createResultValue( result, imageFormatProperties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice ) const - { - return static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Device device; - Result result = static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) ); - return createResultValue( result, device, "VULKAN_HPP_NAMESPACE::PhysicalDevice::createDevice" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueDevice>::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - Device device; - Result result = static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) ); - - DeviceDeleter deleter( allocator ); - return createResultValue( result, device, "VULKAN_HPP_NAMESPACE::PhysicalDevice::createDeviceUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) const - { - return static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type PhysicalDevice::enumerateDeviceLayerProperties() const - { - std::vector<LayerProperties,Allocator> properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::enumerateDeviceLayerProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) const - { - return static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName ) const - { - std::vector<ExtensionProperties,Allocator> properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::enumerateDeviceExtensionProperties" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties ) const - { - 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 ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const - { - std::vector<SparseImageFormatProperties,Allocator> properties; - uint32_t propertyCount; - 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 ); - properties.resize( propertyCount ); - 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() ) ); - return properties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties ) const - { - return static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPropertiesKHR() const - { - std::vector<DisplayPropertiesKHR,Allocator> properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties ) const - { - return static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPlanePropertiesKHR() const - { - std::vector<DisplayPlanePropertiesKHR,Allocator> properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlanePropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays ) const - { - return static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const - { - std::vector<DisplayKHR,Allocator> displays; - uint32_t displayCount; - Result result; - do - { - result = static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && displayCount ) - { - displays.resize( displayCount ); - result = static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( displayCount <= displays.size() ); - displays.resize( displayCount ); - return createResultValue( result, displays, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties ) const - { - return static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display ) const - { - std::vector<DisplayModePropertiesKHR,Allocator> properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); - return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayModePropertiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode ) const - { - return static_cast<Result>( vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DisplayModeKHR mode; - Result result = static_cast<Result>( 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 ) ) ); - return createResultValue( result, mode, "VULKAN_HPP_NAMESPACE::PhysicalDevice::createDisplayModeKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities ) const - { - return static_cast<Result>( vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex ) const - { - DisplayPlaneCapabilitiesKHR capabilities; - Result result = static_cast<Result>( vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) ); - return createResultValue( result, capabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection ) const - { - return vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection ) const - { - return vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) const - { - return static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), pSupported ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface ) const - { - Bool32 supported; - Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), &supported ) ); - return createResultValue( result, supported, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceSupportKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) const - { - return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface ) const - { - SurfaceCapabilitiesKHR surfaceCapabilities; - Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilitiesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const - { - return static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface ) const - { - std::vector<SurfaceFormatKHR,Allocator> surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( surfaceFormatCount <= surfaceFormats.size() ); - surfaceFormats.resize( surfaceFormatCount ); - return createResultValue( result, surfaceFormats, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceFormatsKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const - { - return static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface ) const - { - std::vector<PresentModeKHR,Allocator> presentModes; - uint32_t presentModeCount; - Result result; - do - { - result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( presentModeCount <= presentModes.size() ); - presentModes.resize( presentModeCount ); - return createResultValue( result, presentModes, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfacePresentModesKHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display ) const - { - return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const - { - return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const - { - return vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex ); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const - { - return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const - { - return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const - { - return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const - { - return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const - { - return static_cast<Result>( 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 ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType ) const - { - ExternalImageFormatPropertiesNV externalImageFormatProperties; - Result result = static_cast<Result>( 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 ) ) ); - return createResultValue( result, externalImageFormatProperties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalImageFormatPropertiesNV" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits ) const - { - vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features ) const - { - DeviceGeneratedCommandsLimitsNVX limits; - vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) ); - return limits; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2KHR* pFeatures ) const - { - vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( pFeatures ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PhysicalDeviceFeatures2KHR PhysicalDevice::getFeatures2KHR() const - { - PhysicalDeviceFeatures2KHR features; - vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( &features ) ); - return features; - } - template <typename ...T> - VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getFeatures2KHR() const - { - StructureChain<T...> structureChain; - PhysicalDeviceFeatures2KHR& features = structureChain.template get<PhysicalDeviceFeatures2KHR>(); - vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( &features ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2KHR* pProperties ) const - { - vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PhysicalDeviceProperties2KHR PhysicalDevice::getProperties2KHR() const - { - PhysicalDeviceProperties2KHR properties; - vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( &properties ) ); - return properties; - } - template <typename ...T> - VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getProperties2KHR() const - { - StructureChain<T...> structureChain; - PhysicalDeviceProperties2KHR& properties = structureChain.template get<PhysicalDeviceProperties2KHR>(); - vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( &properties ) ); - return structureChain; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2KHR* pFormatProperties ) const - { - vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( pFormatProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE FormatProperties2KHR PhysicalDevice::getFormatProperties2KHR( Format format ) const - { - FormatProperties2KHR formatProperties; - vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( &formatProperties ) ); - return formatProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, ImageFormatProperties2KHR* pImageFormatProperties ) const - { - return static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( pImageFormatProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2KHR>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const - { - ImageFormatProperties2KHR imageFormatProperties; - Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( &imageFormatProperties ) ) ); - return createResultValue( result, imageFormatProperties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties2KHR" ); - } - template <typename ...T> - VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const - { - StructureChain<T...> structureChain; - ImageFormatProperties2KHR& imageFormatProperties = structureChain.template get<ImageFormatProperties2KHR>(); - Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( &imageFormatProperties ) ) ); - return createResultValue( result, structureChain, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2KHR* pQueueFamilyProperties ) const - { - vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( pQueueFamilyProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2KHR,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR() const - { - std::vector<QueueFamilyProperties2KHR,Allocator> queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( queueFamilyProperties.data() ) ); - return queueFamilyProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2KHR* pMemoryProperties ) const - { - vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( pMemoryProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2KHR PhysicalDevice::getMemoryProperties2KHR() const - { - PhysicalDeviceMemoryProperties2KHR memoryProperties; - vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( &memoryProperties ) ); - return memoryProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2KHR* pProperties ) const - { - vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( pProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2KHR,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const - { - std::vector<SparseImageFormatProperties2KHR,Allocator> properties; - uint32_t propertyCount; - vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( properties.data() ) ); - return properties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const - { - vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHR*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferPropertiesKHR*>( pExternalBufferProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ExternalBufferPropertiesKHR PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const - { - ExternalBufferPropertiesKHR externalBufferProperties; - vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHR*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferPropertiesKHR*>( &externalBufferProperties ) ); - return externalBufferProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const - { - vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHR*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphorePropertiesKHR*>( pExternalSemaphoreProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ExternalSemaphorePropertiesKHR PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const - { - ExternalSemaphorePropertiesKHR externalSemaphoreProperties; - vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHR*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphorePropertiesKHR*>( &externalSemaphoreProperties ) ); - return externalSemaphoreProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const - { - vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfoKHR*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFencePropertiesKHR*>( pExternalFenceProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ExternalFencePropertiesKHR PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const - { - ExternalFencePropertiesKHR externalFenceProperties; - vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfoKHR*>( &externalFenceInfo ), reinterpret_cast<VkExternalFencePropertiesKHR*>( &externalFenceProperties ) ); - return externalFenceProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const - { - return static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); - } -#else - VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const - { - Result result = static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) ); - return createResultValue( result, "VULKAN_HPP_NAMESPACE::PhysicalDevice::releaseDisplayEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT - VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display ) const - { - return static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display ) const - { - Display dpy; - Result result = static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) ); - return createResultValue( result, dpy, "VULKAN_HPP_NAMESPACE::PhysicalDevice::acquireXlibDisplayEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT - VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay ) const - { - return static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const - { - DisplayKHR display; - Result result = static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) ); - return createResultValue( result, display, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getRandROutputDisplayEXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities ) const - { - return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface ) const - { - SurfaceCapabilities2EXT surfaceCapabilities; - Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2EXT" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects ) const - { - return static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface ) const - { - std::vector<Rect2D,Allocator> rects; - uint32_t rectCount; - Result result; - do - { - result = static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && rectCount ) - { - rects.resize( rectCount ); - result = static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( rectCount <= rects.size() ); - rects.resize( rectCount ); - return createResultValue( result, rects, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getPresentRectanglesKHX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties ) const - { - vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( pMultisampleProperties ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const - { - MultisamplePropertiesEXT multisampleProperties; - vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( &multisampleProperties ) ); - return multisampleProperties; - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities ) const - { - return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - SurfaceCapabilities2KHR surfaceCapabilities; - Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2KHR" ); - } - template <typename ...T> - VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - StructureChain<T...> structureChain; - SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>(); - Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) ); - return createResultValue( result, structureChain, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const - { - return static_cast<Result>( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( pSurfaceFormats ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( surfaceFormatCount <= surfaceFormats.size() ); - surfaceFormats.resize( surfaceFormatCount ); - return createResultValue( result, surfaceFormats, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceFormats2KHR" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - struct CmdProcessCommandsInfoNVX - { - 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 ) - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) - , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) - , maxSequencesCount( maxSequencesCount_ ) - , targetCommandBuffer( targetCommandBuffer_ ) - , sequencesCountBuffer( sequencesCountBuffer_ ) - , sequencesCountOffset( sequencesCountOffset_ ) - , sequencesIndexBuffer( sequencesIndexBuffer_ ) - , sequencesIndexOffset( sequencesIndexOffset_ ) - { - } - - CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); - } - - CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) - { - memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); - return *this; - } - CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - CmdProcessCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ ) - { - objectTable = objectTable_; - return *this; - } - - CmdProcessCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ ) - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - CmdProcessCommandsInfoNVX& setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ ) - { - indirectCommandsTokenCount = indirectCommandsTokenCount_; - return *this; - } - - CmdProcessCommandsInfoNVX& setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ ) - { - pIndirectCommandsTokens = pIndirectCommandsTokens_; - return *this; - } - - CmdProcessCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ ) - { - maxSequencesCount = maxSequencesCount_; - return *this; - } - - CmdProcessCommandsInfoNVX& setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ ) - { - targetCommandBuffer = targetCommandBuffer_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesCountBuffer( Buffer sequencesCountBuffer_ ) - { - sequencesCountBuffer = sequencesCountBuffer_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesCountOffset( DeviceSize sequencesCountOffset_ ) - { - sequencesCountOffset = sequencesCountOffset_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ ) - { - sequencesIndexBuffer = sequencesIndexBuffer_; - return *this; - } - - CmdProcessCommandsInfoNVX& setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ ) - { - sequencesIndexOffset = sequencesIndexOffset_; - return *this; - } - - operator const VkCmdProcessCommandsInfoNVX&() const - { - return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this); - } - - bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( objectTable == rhs.objectTable ) - && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) - && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount ) - && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens ) - && ( maxSequencesCount == rhs.maxSequencesCount ) - && ( targetCommandBuffer == rhs.targetCommandBuffer ) - && ( sequencesCountBuffer == rhs.sequencesCountBuffer ) - && ( sequencesCountOffset == rhs.sequencesCountOffset ) - && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) - && ( sequencesIndexOffset == rhs.sequencesIndexOffset ); - } - - bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; - - public: - const void* pNext = nullptr; - ObjectTableNVX objectTable; - IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t indirectCommandsTokenCount; - const IndirectCommandsTokenNVX* pIndirectCommandsTokens; - uint32_t maxSequencesCount; - CommandBuffer targetCommandBuffer; - Buffer sequencesCountBuffer; - DeviceSize sequencesCountOffset; - Buffer sequencesIndexBuffer; - DeviceSize sequencesIndexOffset; - }; - static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" ); - - struct PhysicalDeviceGroupPropertiesKHX - { - operator const VkPhysicalDeviceGroupPropertiesKHX&() const - { - return *reinterpret_cast<const VkPhysicalDeviceGroupPropertiesKHX*>(this); - } - - bool operator==( PhysicalDeviceGroupPropertiesKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( physicalDeviceCount == rhs.physicalDeviceCount ) - && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE_KHX * sizeof( PhysicalDevice ) ) == 0 ) - && ( subsetAllocation == rhs.subsetAllocation ); - } - - bool operator!=( PhysicalDeviceGroupPropertiesKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::ePhysicalDeviceGroupPropertiesKHX; - - public: - void* pNext = nullptr; - uint32_t physicalDeviceCount; - PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX]; - Bool32 subsetAllocation; - }; - static_assert( sizeof( PhysicalDeviceGroupPropertiesKHX ) == sizeof( VkPhysicalDeviceGroupPropertiesKHX ), "struct and wrapper have different size!" ); - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class DebugReportCallbackEXTDeleter; - template <> class UniqueHandleTraits<DebugReportCallbackEXT> {public: using deleter = DebugReportCallbackEXTDeleter; }; - using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT>; - class SurfaceKHRDeleter; - template <> class UniqueHandleTraits<SurfaceKHR> {public: using deleter = SurfaceKHRDeleter; }; - using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR>; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - class Instance - { - public: - Instance() - : m_instance(VK_NULL_HANDLE) - {} - - Instance( std::nullptr_t ) - : m_instance(VK_NULL_HANDLE) - {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) - : m_instance( instance ) - {} - -#if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Instance & operator=(VkInstance instance) - { - m_instance = instance; - return *this; - } -#endif - - Instance & operator=( std::nullptr_t ) - { - m_instance = VK_NULL_HANDLE; - return *this; - } - - bool operator==( Instance const & rhs ) const - { - return m_instance == rhs.m_instance; - } - - bool operator!=(Instance const & rhs ) const - { - return m_instance != rhs.m_instance; - } - - bool operator<(Instance const & rhs ) const - { - return m_instance < rhs.m_instance; - } - - void destroy( const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroy( Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<PhysicalDevice>> - typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PFN_vkVoidFunction getProcAddr( const char* pName ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - PFN_vkVoidFunction getProcAddr( const std::string & name ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - Result createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_VI_NN - Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueDebugReportCallbackEXT>::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Result enumeratePhysicalDeviceGroupsKHX( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator = std::allocator<PhysicalDeviceGroupPropertiesKHX>> - typename ResultValueType<std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator>>::type enumeratePhysicalDeviceGroupsKHX() const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueSurfaceKHR>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const - { - return m_instance; - } - - explicit operator bool() const - { - return m_instance != VK_NULL_HANDLE; - } - - bool operator!() const - { - return m_instance == VK_NULL_HANDLE; - } - - private: - VkInstance m_instance; - }; - - static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class DebugReportCallbackEXTDeleter - { - public: - DebugReportCallbackEXTDeleter( Instance instance = Instance(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_instance( instance ) - , m_allocator( allocator ) - {} - - Instance getInstance() const { return m_instance; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( DebugReportCallbackEXT debugReportCallbackEXT ) - { - m_instance.destroyDebugReportCallbackEXT( debugReportCallbackEXT, m_allocator ); - } - - private: - Instance m_instance; - Optional<const AllocationCallbacks> m_allocator; - }; - - class SurfaceKHRDeleter - { - public: - SurfaceKHRDeleter( Instance instance = Instance(), Optional<const AllocationCallbacks> allocator = nullptr ) - : m_instance( instance ) - , m_allocator( allocator ) - {} - - Instance getInstance() const { return m_instance; } - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( SurfaceKHR surfaceKHR ) - { - m_instance.destroySurfaceKHR( surfaceKHR, m_allocator ); - } - - private: - Instance m_instance; - Optional<const AllocationCallbacks> m_allocator; - }; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator ) const - { - vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices ) const - { - return static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type Instance::enumeratePhysicalDevices() const - { - std::vector<PhysicalDevice,Allocator> physicalDevices; - uint32_t physicalDeviceCount; - Result result; - do - { - result = static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceCount ) - { - physicalDevices.resize( physicalDeviceCount ); - result = static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( physicalDeviceCount <= physicalDevices.size() ); - physicalDevices.resize( physicalDeviceCount ); - return createResultValue( result, physicalDevices, "VULKAN_HPP_NAMESPACE::Instance::enumeratePhysicalDevices" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char* pName ) const - { - return vkGetInstanceProcAddr( m_instance, pName ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name ) const - { - return vkGetInstanceProcAddr( m_instance, name.c_str() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createAndroidSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createAndroidSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createDisplayPlaneSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createDisplayPlaneSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE Result Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMirSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMirSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - - VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator ) const - { - vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_VI_NN - VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createViSurfaceNN" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createViSurfaceNNUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWaylandSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWaylandSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWin32SurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWin32SurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXlibSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXlibSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXcbSurfaceKHR" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXcbSurfaceKHRUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - - VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback ) const - { - return static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DebugReportCallbackEXT callback; - Result result = static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) ); - return createResultValue( result, callback, "VULKAN_HPP_NAMESPACE::Instance::createDebugReportCallbackEXT" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueDebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - DebugReportCallbackEXT callback; - Result result = static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) ); - - DebugReportCallbackEXTDeleter deleter( *this, allocator ); - return createResultValue( result, callback, "VULKAN_HPP_NAMESPACE::Instance::createDebugReportCallbackEXTUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator ) const - { - vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator ) const - { - vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - 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 ) const - { - vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message ) const - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - assert( layerPrefix.size() == message.size() ); -#else - if ( layerPrefix.size() != message.size() ) - { - throw LogicError( "VULKAN_HPP_NAMESPACE::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" ); - } -#endif // VULKAN_HPP_NO_EXCEPTIONS - vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHX( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties ) const - { - return static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX*>( pPhysicalDeviceGroupProperties ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template <typename Allocator> - VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator>>::type Instance::enumeratePhysicalDeviceGroupsKHX() const - { - std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator> physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX*>( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - assert( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - return createResultValue( result, physicalDeviceGroupProperties, "VULKAN_HPP_NAMESPACE::Instance::enumeratePhysicalDeviceGroupsKHX" ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createIOSSurfaceMVK" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createIOSSurfaceMVKUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const - { - return static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMacOSSurfaceMVK" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const - { - SurfaceKHR surface; - Result result = static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) ); - - SurfaceKHRDeleter deleter( *this, allocator ); - return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMacOSSurfaceMVKUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - struct DeviceGroupDeviceCreateInfoKHX - { - DeviceGroupDeviceCreateInfoKHX( uint32_t physicalDeviceCount_ = 0, const PhysicalDevice* pPhysicalDevices_ = nullptr ) - : physicalDeviceCount( physicalDeviceCount_ ) - , pPhysicalDevices( pPhysicalDevices_ ) - { - } - - DeviceGroupDeviceCreateInfoKHX( VkDeviceGroupDeviceCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) ); - } - - DeviceGroupDeviceCreateInfoKHX& operator=( VkDeviceGroupDeviceCreateInfoKHX const & rhs ) - { - memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) ); - return *this; - } - DeviceGroupDeviceCreateInfoKHX& setPNext( const void* pNext_ ) - { - pNext = pNext_; - return *this; - } - - DeviceGroupDeviceCreateInfoKHX& setPhysicalDeviceCount( uint32_t physicalDeviceCount_ ) - { - physicalDeviceCount = physicalDeviceCount_; - return *this; - } - - DeviceGroupDeviceCreateInfoKHX& setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ ) - { - pPhysicalDevices = pPhysicalDevices_; - return *this; - } - - operator const VkDeviceGroupDeviceCreateInfoKHX&() const - { - return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfoKHX*>(this); - } - - bool operator==( DeviceGroupDeviceCreateInfoKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( physicalDeviceCount == rhs.physicalDeviceCount ) - && ( pPhysicalDevices == rhs.pPhysicalDevices ); - } - - bool operator!=( DeviceGroupDeviceCreateInfoKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType = StructureType::eDeviceGroupDeviceCreateInfoKHX; - - public: - const void* pNext = nullptr; - uint32_t physicalDeviceCount; - const PhysicalDevice* pPhysicalDevices; - }; - static_assert( sizeof( DeviceGroupDeviceCreateInfoKHX ) == sizeof( VkDeviceGroupDeviceCreateInfoKHX ), "struct and wrapper have different size!" ); - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class InstanceDeleter; - template <> class UniqueHandleTraits<Instance> {public: using deleter = InstanceDeleter; }; - using UniqueInstance = UniqueHandle<Instance>; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance ); -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ); -#ifndef VULKAN_HPP_NO_SMART_HANDLE - ResultValueType<UniqueInstance>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ); -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class InstanceDeleter - { - public: - InstanceDeleter( Optional<const AllocationCallbacks> allocator = nullptr ) - : m_allocator( allocator ) - {} - - Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; } - - protected: - void destroy( Instance instance ) - { - instance.destroy( m_allocator ); - } - - private: - Optional<const AllocationCallbacks> m_allocator; - }; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance ) - { - return static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) ); - } -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) - { - Instance instance; - Result result = static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) ); - return createResultValue( result, instance, "VULKAN_HPP_NAMESPACE::createInstance" ); - } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - VULKAN_HPP_INLINE ResultValueType<UniqueInstance>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) - { - Instance instance; - Result result = static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) ); - - InstanceDeleter deleter( allocator ); - return createResultValue( result, instance, "VULKAN_HPP_NAMESPACE::createInstanceUnique", deleter ); - } -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - - template <> struct isStructureChainValid<PresentInfoKHR, DisplayPresentInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageCreateInfo, DedicatedAllocationImageCreateInfoNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<BufferCreateInfo, DedicatedAllocationBufferCreateInfoNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<MemoryAllocateInfo, DedicatedAllocationMemoryAllocateInfoNV>{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoNV>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoNV>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFeatures2KHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDevicePushDescriptorPropertiesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceVariablePointerFeaturesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVariablePointerFeaturesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceIDPropertiesKHR>{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoKHR>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoKHR>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreWin32HandleInfoKHR>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<SubmitInfo, D3D12FenceSubmitInfoKHR>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceWin32HandleInfoKHR>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceMultiviewFeaturesKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMultiviewFeaturesKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceMultiviewPropertiesKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassMultiviewCreateInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<BindBufferMemoryInfoKHR, BindBufferMemoryDeviceGroupInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<BindImageMemoryInfoKHR, BindImageMemoryDeviceGroupInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<RenderPassBeginInfo, DeviceGroupRenderPassBeginInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<CommandBufferBeginInfo, DeviceGroupCommandBufferBeginInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<SubmitInfo, DeviceGroupSubmitInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<BindSparseInfo, DeviceGroupBindSparseInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageCreateInfo, ImageSwapchainCreateInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<BindImageMemoryInfoKHR, BindImageMemorySwapchainInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportWScalingStateCreateInfoNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceDiscardRectanglePropertiesEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDevice16BitStorageFeaturesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice16BitStorageFeaturesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<MemoryRequirements2KHR, MemoryDedicatedRequirementsKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryDedicatedAllocateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<SamplerCreateInfo, SamplerYcbcrConversionInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageViewCreateInfo, SamplerYcbcrConversionInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceSamplerYcbcrConversionFeaturesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceSamplerYcbcrConversionFeaturesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageFormatProperties2KHR, SamplerYcbcrConversionImageFormatPropertiesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageFormatProperties2KHR, TextureLODGatherFormatPropertiesAMD>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceConservativeRasterizationPropertiesEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<BindImageMemoryInfoKHR, BindImagePlaneMemoryInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageMemoryRequirementsInfo2KHR, ImagePlaneMemoryRequirementsInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageMemoryBarrier, SampleLocationsInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassSampleLocationsBeginInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineSampleLocationsStateCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceSampleLocationsPropertiesEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<InstanceCreateInfo, DebugReportCallbackCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateRasterizationOrderAMD>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfoNV>{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoNV>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2KHR, PhysicalDeviceExternalImageFormatInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<BufferCreateInfo, ExternalMemoryBufferCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfoKHR>{ enum { value = true }; }; -#ifdef VK_USE_PLATFORM_WIN32_KHR - template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoKHR>{ enum { value = true }; }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryFdInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryHostPointerInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<ImageFormatProperties2KHR, ExternalImageFormatPropertiesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainCounterCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryAllocateFlagsInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<PresentInfoKHR, DeviceGroupPresentInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<SwapchainCreateInfoKHR, DeviceGroupSwapchainCreateInfoKHX>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportSwizzleStateCreateInfoNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDevicePointClippingPropertiesKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<SamplerCreateInfo, SamplerReductionModeCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineTessellationStateCreateInfo, PipelineTessellationDomainOriginStateCreateInfoKHR>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineColorBlendStateCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageModulationStateCreateInfoNV>{ enum { value = true }; }; - template <> struct isStructureChainValid<DeviceQueueCreateInfo, DeviceQueueGlobalPriorityCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; }; - template <> struct isStructureChainValid<DeviceCreateInfo, DeviceGroupDeviceCreateInfoKHX>{ enum { value = true }; }; - VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(EventCreateFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(EventCreateFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryMapFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryMapFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlags) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagBitsKHR) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagsKHR) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagBitsKHR) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagsKHR) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagBitsKHR) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagsKHR) - { - return "{}"; - } - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_MIR_KHR - VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_MIR_KHR*/ - -#ifdef VK_USE_PLATFORM_VI_NN - VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_VI_NN - VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_VI_NN*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XLIB_KHR - VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_XCB_KHR - VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_IOS_MVK - VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBitsKHR) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagsKHR) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagBitsNV) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagsNV) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagBitsNV) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagsNV) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagBitsNV) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagsNV) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT) - { - return "(void)"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagsEXT) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageLayout value) - { - switch (value) - { - case ImageLayout::eUndefined: return "Undefined"; - case ImageLayout::eGeneral: return "General"; - case ImageLayout::eColorAttachmentOptimal: return "ColorAttachmentOptimal"; - case ImageLayout::eDepthStencilAttachmentOptimal: return "DepthStencilAttachmentOptimal"; - case ImageLayout::eDepthStencilReadOnlyOptimal: return "DepthStencilReadOnlyOptimal"; - case ImageLayout::eShaderReadOnlyOptimal: return "ShaderReadOnlyOptimal"; - case ImageLayout::eTransferSrcOptimal: return "TransferSrcOptimal"; - case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal"; - case ImageLayout::ePreinitialized: return "Preinitialized"; - case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR"; - case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR"; - case ImageLayout::eDepthReadOnlyStencilAttachmentOptimalKHR: return "DepthReadOnlyStencilAttachmentOptimalKHR"; - case ImageLayout::eDepthAttachmentStencilReadOnlyOptimalKHR: return "DepthAttachmentStencilReadOnlyOptimalKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentLoadOp value) - { - switch (value) - { - case AttachmentLoadOp::eLoad: return "Load"; - case AttachmentLoadOp::eClear: return "Clear"; - case AttachmentLoadOp::eDontCare: return "DontCare"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentStoreOp value) - { - switch (value) - { - case AttachmentStoreOp::eStore: return "Store"; - case AttachmentStoreOp::eDontCare: return "DontCare"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageType value) - { - switch (value) - { - case ImageType::e1D: return "1D"; - case ImageType::e2D: return "2D"; - case ImageType::e3D: return "3D"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageTiling value) - { - switch (value) - { - case ImageTiling::eOptimal: return "Optimal"; - case ImageTiling::eLinear: return "Linear"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageViewType value) - { - switch (value) - { - case ImageViewType::e1D: return "1D"; - case ImageViewType::e2D: return "2D"; - case ImageViewType::e3D: return "3D"; - case ImageViewType::eCube: return "Cube"; - case ImageViewType::e1DArray: return "1DArray"; - case ImageViewType::e2DArray: return "2DArray"; - case ImageViewType::eCubeArray: return "CubeArray"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferLevel value) - { - switch (value) - { - case CommandBufferLevel::ePrimary: return "Primary"; - case CommandBufferLevel::eSecondary: return "Secondary"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ComponentSwizzle value) - { - switch (value) - { - case ComponentSwizzle::eIdentity: return "Identity"; - case ComponentSwizzle::eZero: return "Zero"; - case ComponentSwizzle::eOne: return "One"; - case ComponentSwizzle::eR: return "R"; - case ComponentSwizzle::eG: return "G"; - case ComponentSwizzle::eB: return "B"; - case ComponentSwizzle::eA: return "A"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorType value) - { - switch (value) - { - case DescriptorType::eSampler: return "Sampler"; - case DescriptorType::eCombinedImageSampler: return "CombinedImageSampler"; - case DescriptorType::eSampledImage: return "SampledImage"; - case DescriptorType::eStorageImage: return "StorageImage"; - case DescriptorType::eUniformTexelBuffer: return "UniformTexelBuffer"; - case DescriptorType::eStorageTexelBuffer: return "StorageTexelBuffer"; - case DescriptorType::eUniformBuffer: return "UniformBuffer"; - case DescriptorType::eStorageBuffer: return "StorageBuffer"; - case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic"; - case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic"; - case DescriptorType::eInputAttachment: return "InputAttachment"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryType value) - { - switch (value) - { - case QueryType::eOcclusion: return "Occlusion"; - case QueryType::ePipelineStatistics: return "PipelineStatistics"; - case QueryType::eTimestamp: return "Timestamp"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BorderColor value) - { - switch (value) - { - case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack"; - case BorderColor::eIntTransparentBlack: return "IntTransparentBlack"; - case BorderColor::eFloatOpaqueBlack: return "FloatOpaqueBlack"; - case BorderColor::eIntOpaqueBlack: return "IntOpaqueBlack"; - case BorderColor::eFloatOpaqueWhite: return "FloatOpaqueWhite"; - case BorderColor::eIntOpaqueWhite: return "IntOpaqueWhite"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineBindPoint value) - { - switch (value) - { - case PipelineBindPoint::eGraphics: return "Graphics"; - case PipelineBindPoint::eCompute: return "Compute"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCacheHeaderVersion value) - { - switch (value) - { - case PipelineCacheHeaderVersion::eOne: return "One"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PrimitiveTopology value) - { - switch (value) - { - case PrimitiveTopology::ePointList: return "PointList"; - case PrimitiveTopology::eLineList: return "LineList"; - case PrimitiveTopology::eLineStrip: return "LineStrip"; - case PrimitiveTopology::eTriangleList: return "TriangleList"; - case PrimitiveTopology::eTriangleStrip: return "TriangleStrip"; - case PrimitiveTopology::eTriangleFan: return "TriangleFan"; - case PrimitiveTopology::eLineListWithAdjacency: return "LineListWithAdjacency"; - case PrimitiveTopology::eLineStripWithAdjacency: return "LineStripWithAdjacency"; - case PrimitiveTopology::eTriangleListWithAdjacency: return "TriangleListWithAdjacency"; - case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency"; - case PrimitiveTopology::ePatchList: return "PatchList"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SharingMode value) - { - switch (value) - { - case SharingMode::eExclusive: return "Exclusive"; - case SharingMode::eConcurrent: return "Concurrent"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(IndexType value) - { - switch (value) - { - case IndexType::eUint16: return "Uint16"; - case IndexType::eUint32: return "Uint32"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(Filter value) - { - switch (value) - { - case Filter::eNearest: return "Nearest"; - case Filter::eLinear: return "Linear"; - case Filter::eCubicIMG: return "CubicIMG"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerMipmapMode value) - { - switch (value) - { - case SamplerMipmapMode::eNearest: return "Nearest"; - case SamplerMipmapMode::eLinear: return "Linear"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerAddressMode value) - { - switch (value) - { - case SamplerAddressMode::eRepeat: return "Repeat"; - case SamplerAddressMode::eMirroredRepeat: return "MirroredRepeat"; - case SamplerAddressMode::eClampToEdge: return "ClampToEdge"; - case SamplerAddressMode::eClampToBorder: return "ClampToBorder"; - case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CompareOp value) - { - switch (value) - { - case CompareOp::eNever: return "Never"; - case CompareOp::eLess: return "Less"; - case CompareOp::eEqual: return "Equal"; - case CompareOp::eLessOrEqual: return "LessOrEqual"; - case CompareOp::eGreater: return "Greater"; - case CompareOp::eNotEqual: return "NotEqual"; - case CompareOp::eGreaterOrEqual: return "GreaterOrEqual"; - case CompareOp::eAlways: return "Always"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PolygonMode value) - { - switch (value) - { - case PolygonMode::eFill: return "Fill"; - case PolygonMode::eLine: return "Line"; - case PolygonMode::ePoint: return "Point"; - case PolygonMode::eFillRectangleNV: return "FillRectangleNV"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CullModeFlagBits value) - { - switch (value) - { - case CullModeFlagBits::eNone: return "None"; - case CullModeFlagBits::eFront: return "Front"; - case CullModeFlagBits::eBack: return "Back"; - case CullModeFlagBits::eFrontAndBack: return "FrontAndBack"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CullModeFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CullModeFlagBits::eNone) result += "None | "; - if (value & CullModeFlagBits::eFront) result += "Front | "; - if (value & CullModeFlagBits::eBack) result += "Back | "; - if (value & CullModeFlagBits::eFrontAndBack) result += "FrontAndBack | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FrontFace value) - { - switch (value) - { - case FrontFace::eCounterClockwise: return "CounterClockwise"; - case FrontFace::eClockwise: return "Clockwise"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BlendFactor value) - { - switch (value) - { - case BlendFactor::eZero: return "Zero"; - case BlendFactor::eOne: return "One"; - case BlendFactor::eSrcColor: return "SrcColor"; - case BlendFactor::eOneMinusSrcColor: return "OneMinusSrcColor"; - case BlendFactor::eDstColor: return "DstColor"; - case BlendFactor::eOneMinusDstColor: return "OneMinusDstColor"; - case BlendFactor::eSrcAlpha: return "SrcAlpha"; - case BlendFactor::eOneMinusSrcAlpha: return "OneMinusSrcAlpha"; - case BlendFactor::eDstAlpha: return "DstAlpha"; - case BlendFactor::eOneMinusDstAlpha: return "OneMinusDstAlpha"; - case BlendFactor::eConstantColor: return "ConstantColor"; - case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor"; - case BlendFactor::eConstantAlpha: return "ConstantAlpha"; - case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha"; - case BlendFactor::eSrcAlphaSaturate: return "SrcAlphaSaturate"; - case BlendFactor::eSrc1Color: return "Src1Color"; - case BlendFactor::eOneMinusSrc1Color: return "OneMinusSrc1Color"; - case BlendFactor::eSrc1Alpha: return "Src1Alpha"; - case BlendFactor::eOneMinusSrc1Alpha: return "OneMinusSrc1Alpha"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BlendOp value) - { - switch (value) - { - case BlendOp::eAdd: return "Add"; - case BlendOp::eSubtract: return "Subtract"; - case BlendOp::eReverseSubtract: return "ReverseSubtract"; - case BlendOp::eMin: return "Min"; - case BlendOp::eMax: return "Max"; - case BlendOp::eZeroEXT: return "ZeroEXT"; - case BlendOp::eSrcEXT: return "SrcEXT"; - case BlendOp::eDstEXT: return "DstEXT"; - case BlendOp::eSrcOverEXT: return "SrcOverEXT"; - case BlendOp::eDstOverEXT: return "DstOverEXT"; - case BlendOp::eSrcInEXT: return "SrcInEXT"; - case BlendOp::eDstInEXT: return "DstInEXT"; - case BlendOp::eSrcOutEXT: return "SrcOutEXT"; - case BlendOp::eDstOutEXT: return "DstOutEXT"; - case BlendOp::eSrcAtopEXT: return "SrcAtopEXT"; - case BlendOp::eDstAtopEXT: return "DstAtopEXT"; - case BlendOp::eXorEXT: return "XorEXT"; - case BlendOp::eMultiplyEXT: return "MultiplyEXT"; - case BlendOp::eScreenEXT: return "ScreenEXT"; - case BlendOp::eOverlayEXT: return "OverlayEXT"; - case BlendOp::eDarkenEXT: return "DarkenEXT"; - case BlendOp::eLightenEXT: return "LightenEXT"; - case BlendOp::eColordodgeEXT: return "ColordodgeEXT"; - case BlendOp::eColorburnEXT: return "ColorburnEXT"; - case BlendOp::eHardlightEXT: return "HardlightEXT"; - case BlendOp::eSoftlightEXT: return "SoftlightEXT"; - case BlendOp::eDifferenceEXT: return "DifferenceEXT"; - case BlendOp::eExclusionEXT: return "ExclusionEXT"; - case BlendOp::eInvertEXT: return "InvertEXT"; - case BlendOp::eInvertRgbEXT: return "InvertRgbEXT"; - case BlendOp::eLineardodgeEXT: return "LineardodgeEXT"; - case BlendOp::eLinearburnEXT: return "LinearburnEXT"; - case BlendOp::eVividlightEXT: return "VividlightEXT"; - case BlendOp::eLinearlightEXT: return "LinearlightEXT"; - case BlendOp::ePinlightEXT: return "PinlightEXT"; - case BlendOp::eHardmixEXT: return "HardmixEXT"; - case BlendOp::eHslHueEXT: return "HslHueEXT"; - case BlendOp::eHslSaturationEXT: return "HslSaturationEXT"; - case BlendOp::eHslColorEXT: return "HslColorEXT"; - case BlendOp::eHslLuminosityEXT: return "HslLuminosityEXT"; - case BlendOp::ePlusEXT: return "PlusEXT"; - case BlendOp::ePlusClampedEXT: return "PlusClampedEXT"; - case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT"; - case BlendOp::ePlusDarkerEXT: return "PlusDarkerEXT"; - case BlendOp::eMinusEXT: return "MinusEXT"; - case BlendOp::eMinusClampedEXT: return "MinusClampedEXT"; - case BlendOp::eContrastEXT: return "ContrastEXT"; - case BlendOp::eInvertOvgEXT: return "InvertOvgEXT"; - case BlendOp::eRedEXT: return "RedEXT"; - case BlendOp::eGreenEXT: return "GreenEXT"; - case BlendOp::eBlueEXT: return "BlueEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(StencilOp value) - { - switch (value) - { - case StencilOp::eKeep: return "Keep"; - case StencilOp::eZero: return "Zero"; - case StencilOp::eReplace: return "Replace"; - case StencilOp::eIncrementAndClamp: return "IncrementAndClamp"; - case StencilOp::eDecrementAndClamp: return "DecrementAndClamp"; - case StencilOp::eInvert: return "Invert"; - case StencilOp::eIncrementAndWrap: return "IncrementAndWrap"; - case StencilOp::eDecrementAndWrap: return "DecrementAndWrap"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(LogicOp value) - { - switch (value) - { - case LogicOp::eClear: return "Clear"; - case LogicOp::eAnd: return "And"; - case LogicOp::eAndReverse: return "AndReverse"; - case LogicOp::eCopy: return "Copy"; - case LogicOp::eAndInverted: return "AndInverted"; - case LogicOp::eNoOp: return "NoOp"; - case LogicOp::eXor: return "Xor"; - case LogicOp::eOr: return "Or"; - case LogicOp::eNor: return "Nor"; - case LogicOp::eEquivalent: return "Equivalent"; - case LogicOp::eInvert: return "Invert"; - case LogicOp::eOrReverse: return "OrReverse"; - case LogicOp::eCopyInverted: return "CopyInverted"; - case LogicOp::eOrInverted: return "OrInverted"; - case LogicOp::eNand: return "Nand"; - case LogicOp::eSet: return "Set"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(InternalAllocationType value) - { - switch (value) - { - case InternalAllocationType::eExecutable: return "Executable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SystemAllocationScope value) - { - switch (value) - { - case SystemAllocationScope::eCommand: return "Command"; - case SystemAllocationScope::eObject: return "Object"; - case SystemAllocationScope::eCache: return "Cache"; - case SystemAllocationScope::eDevice: return "Device"; - case SystemAllocationScope::eInstance: return "Instance"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PhysicalDeviceType value) - { - switch (value) - { - case PhysicalDeviceType::eOther: return "Other"; - case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu"; - case PhysicalDeviceType::eDiscreteGpu: return "DiscreteGpu"; - case PhysicalDeviceType::eVirtualGpu: return "VirtualGpu"; - case PhysicalDeviceType::eCpu: return "Cpu"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(VertexInputRate value) - { - switch (value) - { - case VertexInputRate::eVertex: return "Vertex"; - case VertexInputRate::eInstance: return "Instance"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(Format value) - { - switch (value) - { - case Format::eUndefined: return "Undefined"; - case Format::eR4G4UnormPack8: return "R4G4UnormPack8"; - case Format::eR4G4B4A4UnormPack16: return "R4G4B4A4UnormPack16"; - case Format::eB4G4R4A4UnormPack16: return "B4G4R4A4UnormPack16"; - case Format::eR5G6B5UnormPack16: return "R5G6B5UnormPack16"; - case Format::eB5G6R5UnormPack16: return "B5G6R5UnormPack16"; - case Format::eR5G5B5A1UnormPack16: return "R5G5B5A1UnormPack16"; - case Format::eB5G5R5A1UnormPack16: return "B5G5R5A1UnormPack16"; - case Format::eA1R5G5B5UnormPack16: return "A1R5G5B5UnormPack16"; - case Format::eR8Unorm: return "R8Unorm"; - case Format::eR8Snorm: return "R8Snorm"; - case Format::eR8Uscaled: return "R8Uscaled"; - case Format::eR8Sscaled: return "R8Sscaled"; - case Format::eR8Uint: return "R8Uint"; - case Format::eR8Sint: return "R8Sint"; - case Format::eR8Srgb: return "R8Srgb"; - case Format::eR8G8Unorm: return "R8G8Unorm"; - case Format::eR8G8Snorm: return "R8G8Snorm"; - case Format::eR8G8Uscaled: return "R8G8Uscaled"; - case Format::eR8G8Sscaled: return "R8G8Sscaled"; - case Format::eR8G8Uint: return "R8G8Uint"; - case Format::eR8G8Sint: return "R8G8Sint"; - case Format::eR8G8Srgb: return "R8G8Srgb"; - case Format::eR8G8B8Unorm: return "R8G8B8Unorm"; - case Format::eR8G8B8Snorm: return "R8G8B8Snorm"; - case Format::eR8G8B8Uscaled: return "R8G8B8Uscaled"; - case Format::eR8G8B8Sscaled: return "R8G8B8Sscaled"; - case Format::eR8G8B8Uint: return "R8G8B8Uint"; - case Format::eR8G8B8Sint: return "R8G8B8Sint"; - case Format::eR8G8B8Srgb: return "R8G8B8Srgb"; - case Format::eB8G8R8Unorm: return "B8G8R8Unorm"; - case Format::eB8G8R8Snorm: return "B8G8R8Snorm"; - case Format::eB8G8R8Uscaled: return "B8G8R8Uscaled"; - case Format::eB8G8R8Sscaled: return "B8G8R8Sscaled"; - case Format::eB8G8R8Uint: return "B8G8R8Uint"; - case Format::eB8G8R8Sint: return "B8G8R8Sint"; - case Format::eB8G8R8Srgb: return "B8G8R8Srgb"; - case Format::eR8G8B8A8Unorm: return "R8G8B8A8Unorm"; - case Format::eR8G8B8A8Snorm: return "R8G8B8A8Snorm"; - case Format::eR8G8B8A8Uscaled: return "R8G8B8A8Uscaled"; - case Format::eR8G8B8A8Sscaled: return "R8G8B8A8Sscaled"; - case Format::eR8G8B8A8Uint: return "R8G8B8A8Uint"; - case Format::eR8G8B8A8Sint: return "R8G8B8A8Sint"; - case Format::eR8G8B8A8Srgb: return "R8G8B8A8Srgb"; - case Format::eB8G8R8A8Unorm: return "B8G8R8A8Unorm"; - case Format::eB8G8R8A8Snorm: return "B8G8R8A8Snorm"; - case Format::eB8G8R8A8Uscaled: return "B8G8R8A8Uscaled"; - case Format::eB8G8R8A8Sscaled: return "B8G8R8A8Sscaled"; - case Format::eB8G8R8A8Uint: return "B8G8R8A8Uint"; - case Format::eB8G8R8A8Sint: return "B8G8R8A8Sint"; - case Format::eB8G8R8A8Srgb: return "B8G8R8A8Srgb"; - case Format::eA8B8G8R8UnormPack32: return "A8B8G8R8UnormPack32"; - case Format::eA8B8G8R8SnormPack32: return "A8B8G8R8SnormPack32"; - case Format::eA8B8G8R8UscaledPack32: return "A8B8G8R8UscaledPack32"; - case Format::eA8B8G8R8SscaledPack32: return "A8B8G8R8SscaledPack32"; - case Format::eA8B8G8R8UintPack32: return "A8B8G8R8UintPack32"; - case Format::eA8B8G8R8SintPack32: return "A8B8G8R8SintPack32"; - case Format::eA8B8G8R8SrgbPack32: return "A8B8G8R8SrgbPack32"; - case Format::eA2R10G10B10UnormPack32: return "A2R10G10B10UnormPack32"; - case Format::eA2R10G10B10SnormPack32: return "A2R10G10B10SnormPack32"; - case Format::eA2R10G10B10UscaledPack32: return "A2R10G10B10UscaledPack32"; - case Format::eA2R10G10B10SscaledPack32: return "A2R10G10B10SscaledPack32"; - case Format::eA2R10G10B10UintPack32: return "A2R10G10B10UintPack32"; - case Format::eA2R10G10B10SintPack32: return "A2R10G10B10SintPack32"; - case Format::eA2B10G10R10UnormPack32: return "A2B10G10R10UnormPack32"; - case Format::eA2B10G10R10SnormPack32: return "A2B10G10R10SnormPack32"; - case Format::eA2B10G10R10UscaledPack32: return "A2B10G10R10UscaledPack32"; - case Format::eA2B10G10R10SscaledPack32: return "A2B10G10R10SscaledPack32"; - case Format::eA2B10G10R10UintPack32: return "A2B10G10R10UintPack32"; - case Format::eA2B10G10R10SintPack32: return "A2B10G10R10SintPack32"; - case Format::eR16Unorm: return "R16Unorm"; - case Format::eR16Snorm: return "R16Snorm"; - case Format::eR16Uscaled: return "R16Uscaled"; - case Format::eR16Sscaled: return "R16Sscaled"; - case Format::eR16Uint: return "R16Uint"; - case Format::eR16Sint: return "R16Sint"; - case Format::eR16Sfloat: return "R16Sfloat"; - case Format::eR16G16Unorm: return "R16G16Unorm"; - case Format::eR16G16Snorm: return "R16G16Snorm"; - case Format::eR16G16Uscaled: return "R16G16Uscaled"; - case Format::eR16G16Sscaled: return "R16G16Sscaled"; - case Format::eR16G16Uint: return "R16G16Uint"; - case Format::eR16G16Sint: return "R16G16Sint"; - case Format::eR16G16Sfloat: return "R16G16Sfloat"; - case Format::eR16G16B16Unorm: return "R16G16B16Unorm"; - case Format::eR16G16B16Snorm: return "R16G16B16Snorm"; - case Format::eR16G16B16Uscaled: return "R16G16B16Uscaled"; - case Format::eR16G16B16Sscaled: return "R16G16B16Sscaled"; - case Format::eR16G16B16Uint: return "R16G16B16Uint"; - case Format::eR16G16B16Sint: return "R16G16B16Sint"; - case Format::eR16G16B16Sfloat: return "R16G16B16Sfloat"; - case Format::eR16G16B16A16Unorm: return "R16G16B16A16Unorm"; - case Format::eR16G16B16A16Snorm: return "R16G16B16A16Snorm"; - case Format::eR16G16B16A16Uscaled: return "R16G16B16A16Uscaled"; - case Format::eR16G16B16A16Sscaled: return "R16G16B16A16Sscaled"; - case Format::eR16G16B16A16Uint: return "R16G16B16A16Uint"; - case Format::eR16G16B16A16Sint: return "R16G16B16A16Sint"; - case Format::eR16G16B16A16Sfloat: return "R16G16B16A16Sfloat"; - case Format::eR32Uint: return "R32Uint"; - case Format::eR32Sint: return "R32Sint"; - case Format::eR32Sfloat: return "R32Sfloat"; - case Format::eR32G32Uint: return "R32G32Uint"; - case Format::eR32G32Sint: return "R32G32Sint"; - case Format::eR32G32Sfloat: return "R32G32Sfloat"; - case Format::eR32G32B32Uint: return "R32G32B32Uint"; - case Format::eR32G32B32Sint: return "R32G32B32Sint"; - case Format::eR32G32B32Sfloat: return "R32G32B32Sfloat"; - case Format::eR32G32B32A32Uint: return "R32G32B32A32Uint"; - case Format::eR32G32B32A32Sint: return "R32G32B32A32Sint"; - case Format::eR32G32B32A32Sfloat: return "R32G32B32A32Sfloat"; - case Format::eR64Uint: return "R64Uint"; - case Format::eR64Sint: return "R64Sint"; - case Format::eR64Sfloat: return "R64Sfloat"; - case Format::eR64G64Uint: return "R64G64Uint"; - case Format::eR64G64Sint: return "R64G64Sint"; - case Format::eR64G64Sfloat: return "R64G64Sfloat"; - case Format::eR64G64B64Uint: return "R64G64B64Uint"; - case Format::eR64G64B64Sint: return "R64G64B64Sint"; - case Format::eR64G64B64Sfloat: return "R64G64B64Sfloat"; - case Format::eR64G64B64A64Uint: return "R64G64B64A64Uint"; - case Format::eR64G64B64A64Sint: return "R64G64B64A64Sint"; - case Format::eR64G64B64A64Sfloat: return "R64G64B64A64Sfloat"; - case Format::eB10G11R11UfloatPack32: return "B10G11R11UfloatPack32"; - case Format::eE5B9G9R9UfloatPack32: return "E5B9G9R9UfloatPack32"; - case Format::eD16Unorm: return "D16Unorm"; - case Format::eX8D24UnormPack32: return "X8D24UnormPack32"; - case Format::eD32Sfloat: return "D32Sfloat"; - case Format::eS8Uint: return "S8Uint"; - case Format::eD16UnormS8Uint: return "D16UnormS8Uint"; - case Format::eD24UnormS8Uint: return "D24UnormS8Uint"; - case Format::eD32SfloatS8Uint: return "D32SfloatS8Uint"; - case Format::eBc1RgbUnormBlock: return "Bc1RgbUnormBlock"; - case Format::eBc1RgbSrgbBlock: return "Bc1RgbSrgbBlock"; - case Format::eBc1RgbaUnormBlock: return "Bc1RgbaUnormBlock"; - case Format::eBc1RgbaSrgbBlock: return "Bc1RgbaSrgbBlock"; - case Format::eBc2UnormBlock: return "Bc2UnormBlock"; - case Format::eBc2SrgbBlock: return "Bc2SrgbBlock"; - case Format::eBc3UnormBlock: return "Bc3UnormBlock"; - case Format::eBc3SrgbBlock: return "Bc3SrgbBlock"; - case Format::eBc4UnormBlock: return "Bc4UnormBlock"; - case Format::eBc4SnormBlock: return "Bc4SnormBlock"; - case Format::eBc5UnormBlock: return "Bc5UnormBlock"; - case Format::eBc5SnormBlock: return "Bc5SnormBlock"; - case Format::eBc6HUfloatBlock: return "Bc6HUfloatBlock"; - case Format::eBc6HSfloatBlock: return "Bc6HSfloatBlock"; - case Format::eBc7UnormBlock: return "Bc7UnormBlock"; - case Format::eBc7SrgbBlock: return "Bc7SrgbBlock"; - case Format::eEtc2R8G8B8UnormBlock: return "Etc2R8G8B8UnormBlock"; - case Format::eEtc2R8G8B8SrgbBlock: return "Etc2R8G8B8SrgbBlock"; - case Format::eEtc2R8G8B8A1UnormBlock: return "Etc2R8G8B8A1UnormBlock"; - case Format::eEtc2R8G8B8A1SrgbBlock: return "Etc2R8G8B8A1SrgbBlock"; - case Format::eEtc2R8G8B8A8UnormBlock: return "Etc2R8G8B8A8UnormBlock"; - case Format::eEtc2R8G8B8A8SrgbBlock: return "Etc2R8G8B8A8SrgbBlock"; - case Format::eEacR11UnormBlock: return "EacR11UnormBlock"; - case Format::eEacR11SnormBlock: return "EacR11SnormBlock"; - case Format::eEacR11G11UnormBlock: return "EacR11G11UnormBlock"; - case Format::eEacR11G11SnormBlock: return "EacR11G11SnormBlock"; - case Format::eAstc4x4UnormBlock: return "Astc4x4UnormBlock"; - case Format::eAstc4x4SrgbBlock: return "Astc4x4SrgbBlock"; - case Format::eAstc5x4UnormBlock: return "Astc5x4UnormBlock"; - case Format::eAstc5x4SrgbBlock: return "Astc5x4SrgbBlock"; - case Format::eAstc5x5UnormBlock: return "Astc5x5UnormBlock"; - case Format::eAstc5x5SrgbBlock: return "Astc5x5SrgbBlock"; - case Format::eAstc6x5UnormBlock: return "Astc6x5UnormBlock"; - case Format::eAstc6x5SrgbBlock: return "Astc6x5SrgbBlock"; - case Format::eAstc6x6UnormBlock: return "Astc6x6UnormBlock"; - case Format::eAstc6x6SrgbBlock: return "Astc6x6SrgbBlock"; - case Format::eAstc8x5UnormBlock: return "Astc8x5UnormBlock"; - case Format::eAstc8x5SrgbBlock: return "Astc8x5SrgbBlock"; - case Format::eAstc8x6UnormBlock: return "Astc8x6UnormBlock"; - case Format::eAstc8x6SrgbBlock: return "Astc8x6SrgbBlock"; - case Format::eAstc8x8UnormBlock: return "Astc8x8UnormBlock"; - case Format::eAstc8x8SrgbBlock: return "Astc8x8SrgbBlock"; - case Format::eAstc10x5UnormBlock: return "Astc10x5UnormBlock"; - case Format::eAstc10x5SrgbBlock: return "Astc10x5SrgbBlock"; - case Format::eAstc10x6UnormBlock: return "Astc10x6UnormBlock"; - case Format::eAstc10x6SrgbBlock: return "Astc10x6SrgbBlock"; - case Format::eAstc10x8UnormBlock: return "Astc10x8UnormBlock"; - case Format::eAstc10x8SrgbBlock: return "Astc10x8SrgbBlock"; - case Format::eAstc10x10UnormBlock: return "Astc10x10UnormBlock"; - case Format::eAstc10x10SrgbBlock: return "Astc10x10SrgbBlock"; - case Format::eAstc12x10UnormBlock: return "Astc12x10UnormBlock"; - case Format::eAstc12x10SrgbBlock: return "Astc12x10SrgbBlock"; - case Format::eAstc12x12UnormBlock: return "Astc12x12UnormBlock"; - case Format::eAstc12x12SrgbBlock: return "Astc12x12SrgbBlock"; - case Format::ePvrtc12BppUnormBlockIMG: return "Pvrtc12BppUnormBlockIMG"; - case Format::ePvrtc14BppUnormBlockIMG: return "Pvrtc14BppUnormBlockIMG"; - case Format::ePvrtc22BppUnormBlockIMG: return "Pvrtc22BppUnormBlockIMG"; - case Format::ePvrtc24BppUnormBlockIMG: return "Pvrtc24BppUnormBlockIMG"; - case Format::ePvrtc12BppSrgbBlockIMG: return "Pvrtc12BppSrgbBlockIMG"; - case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG"; - case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG"; - case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG"; - case Format::eG8B8G8R8422UnormKHR: return "G8B8G8R8422UnormKHR"; - case Format::eB8G8R8G8422UnormKHR: return "B8G8R8G8422UnormKHR"; - case Format::eG8B8R83Plane420UnormKHR: return "G8B8R83Plane420UnormKHR"; - case Format::eG8B8R82Plane420UnormKHR: return "G8B8R82Plane420UnormKHR"; - case Format::eG8B8R83Plane422UnormKHR: return "G8B8R83Plane422UnormKHR"; - case Format::eG8B8R82Plane422UnormKHR: return "G8B8R82Plane422UnormKHR"; - case Format::eG8B8R83Plane444UnormKHR: return "G8B8R83Plane444UnormKHR"; - case Format::eR10X6UnormPack16KHR: return "R10X6UnormPack16KHR"; - case Format::eR10X6G10X6Unorm2Pack16KHR: return "R10X6G10X6Unorm2Pack16KHR"; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16KHR: return "R10X6G10X6B10X6A10X6Unorm4Pack16KHR"; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR: return "G10X6B10X6G10X6R10X6422Unorm4Pack16KHR"; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR: return "B10X6G10X6R10X6G10X6422Unorm4Pack16KHR"; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16KHR: return "G10X6B10X6R10X63Plane420Unorm3Pack16KHR"; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16KHR: return "G10X6B10X6R10X62Plane420Unorm3Pack16KHR"; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16KHR: return "G10X6B10X6R10X63Plane422Unorm3Pack16KHR"; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16KHR: return "G10X6B10X6R10X62Plane422Unorm3Pack16KHR"; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16KHR: return "G10X6B10X6R10X63Plane444Unorm3Pack16KHR"; - case Format::eR12X4UnormPack16KHR: return "R12X4UnormPack16KHR"; - case Format::eR12X4G12X4Unorm2Pack16KHR: return "R12X4G12X4Unorm2Pack16KHR"; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16KHR: return "R12X4G12X4B12X4A12X4Unorm4Pack16KHR"; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR: return "G12X4B12X4G12X4R12X4422Unorm4Pack16KHR"; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR: return "B12X4G12X4R12X4G12X4422Unorm4Pack16KHR"; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16KHR: return "G12X4B12X4R12X43Plane420Unorm3Pack16KHR"; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16KHR: return "G12X4B12X4R12X42Plane420Unorm3Pack16KHR"; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16KHR: return "G12X4B12X4R12X43Plane422Unorm3Pack16KHR"; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16KHR: return "G12X4B12X4R12X42Plane422Unorm3Pack16KHR"; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16KHR: return "G12X4B12X4R12X43Plane444Unorm3Pack16KHR"; - case Format::eG16B16G16R16422UnormKHR: return "G16B16G16R16422UnormKHR"; - case Format::eB16G16R16G16422UnormKHR: return "B16G16R16G16422UnormKHR"; - case Format::eG16B16R163Plane420UnormKHR: return "G16B16R163Plane420UnormKHR"; - case Format::eG16B16R162Plane420UnormKHR: return "G16B16R162Plane420UnormKHR"; - case Format::eG16B16R163Plane422UnormKHR: return "G16B16R163Plane422UnormKHR"; - case Format::eG16B16R162Plane422UnormKHR: return "G16B16R162Plane422UnormKHR"; - case Format::eG16B16R163Plane444UnormKHR: return "G16B16R163Plane444UnormKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(StructureType value) - { - switch (value) - { - case StructureType::eApplicationInfo: return "ApplicationInfo"; - case StructureType::eInstanceCreateInfo: return "InstanceCreateInfo"; - case StructureType::eDeviceQueueCreateInfo: return "DeviceQueueCreateInfo"; - case StructureType::eDeviceCreateInfo: return "DeviceCreateInfo"; - case StructureType::eSubmitInfo: return "SubmitInfo"; - case StructureType::eMemoryAllocateInfo: return "MemoryAllocateInfo"; - case StructureType::eMappedMemoryRange: return "MappedMemoryRange"; - case StructureType::eBindSparseInfo: return "BindSparseInfo"; - case StructureType::eFenceCreateInfo: return "FenceCreateInfo"; - case StructureType::eSemaphoreCreateInfo: return "SemaphoreCreateInfo"; - case StructureType::eEventCreateInfo: return "EventCreateInfo"; - case StructureType::eQueryPoolCreateInfo: return "QueryPoolCreateInfo"; - case StructureType::eBufferCreateInfo: return "BufferCreateInfo"; - case StructureType::eBufferViewCreateInfo: return "BufferViewCreateInfo"; - case StructureType::eImageCreateInfo: return "ImageCreateInfo"; - case StructureType::eImageViewCreateInfo: return "ImageViewCreateInfo"; - case StructureType::eShaderModuleCreateInfo: return "ShaderModuleCreateInfo"; - case StructureType::ePipelineCacheCreateInfo: return "PipelineCacheCreateInfo"; - case StructureType::ePipelineShaderStageCreateInfo: return "PipelineShaderStageCreateInfo"; - case StructureType::ePipelineVertexInputStateCreateInfo: return "PipelineVertexInputStateCreateInfo"; - case StructureType::ePipelineInputAssemblyStateCreateInfo: return "PipelineInputAssemblyStateCreateInfo"; - case StructureType::ePipelineTessellationStateCreateInfo: return "PipelineTessellationStateCreateInfo"; - case StructureType::ePipelineViewportStateCreateInfo: return "PipelineViewportStateCreateInfo"; - case StructureType::ePipelineRasterizationStateCreateInfo: return "PipelineRasterizationStateCreateInfo"; - case StructureType::ePipelineMultisampleStateCreateInfo: return "PipelineMultisampleStateCreateInfo"; - case StructureType::ePipelineDepthStencilStateCreateInfo: return "PipelineDepthStencilStateCreateInfo"; - case StructureType::ePipelineColorBlendStateCreateInfo: return "PipelineColorBlendStateCreateInfo"; - case StructureType::ePipelineDynamicStateCreateInfo: return "PipelineDynamicStateCreateInfo"; - case StructureType::eGraphicsPipelineCreateInfo: return "GraphicsPipelineCreateInfo"; - case StructureType::eComputePipelineCreateInfo: return "ComputePipelineCreateInfo"; - case StructureType::ePipelineLayoutCreateInfo: return "PipelineLayoutCreateInfo"; - case StructureType::eSamplerCreateInfo: return "SamplerCreateInfo"; - case StructureType::eDescriptorSetLayoutCreateInfo: return "DescriptorSetLayoutCreateInfo"; - case StructureType::eDescriptorPoolCreateInfo: return "DescriptorPoolCreateInfo"; - case StructureType::eDescriptorSetAllocateInfo: return "DescriptorSetAllocateInfo"; - case StructureType::eWriteDescriptorSet: return "WriteDescriptorSet"; - case StructureType::eCopyDescriptorSet: return "CopyDescriptorSet"; - case StructureType::eFramebufferCreateInfo: return "FramebufferCreateInfo"; - case StructureType::eRenderPassCreateInfo: return "RenderPassCreateInfo"; - case StructureType::eCommandPoolCreateInfo: return "CommandPoolCreateInfo"; - case StructureType::eCommandBufferAllocateInfo: return "CommandBufferAllocateInfo"; - case StructureType::eCommandBufferInheritanceInfo: return "CommandBufferInheritanceInfo"; - case StructureType::eCommandBufferBeginInfo: return "CommandBufferBeginInfo"; - case StructureType::eRenderPassBeginInfo: return "RenderPassBeginInfo"; - case StructureType::eBufferMemoryBarrier: return "BufferMemoryBarrier"; - case StructureType::eImageMemoryBarrier: return "ImageMemoryBarrier"; - case StructureType::eMemoryBarrier: return "MemoryBarrier"; - case StructureType::eLoaderInstanceCreateInfo: return "LoaderInstanceCreateInfo"; - case StructureType::eLoaderDeviceCreateInfo: return "LoaderDeviceCreateInfo"; - case StructureType::eSwapchainCreateInfoKHR: return "SwapchainCreateInfoKHR"; - case StructureType::ePresentInfoKHR: return "PresentInfoKHR"; - case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR"; - case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR"; - case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR"; - case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR"; - case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR"; - case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR"; - case StructureType::eMirSurfaceCreateInfoKHR: return "MirSurfaceCreateInfoKHR"; - case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR"; - case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR"; - case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT"; - case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD"; - case StructureType::eDebugMarkerObjectNameInfoEXT: return "DebugMarkerObjectNameInfoEXT"; - case StructureType::eDebugMarkerObjectTagInfoEXT: return "DebugMarkerObjectTagInfoEXT"; - case StructureType::eDebugMarkerMarkerInfoEXT: return "DebugMarkerMarkerInfoEXT"; - case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV"; - case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV"; - case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV"; - case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD"; - case StructureType::eRenderPassMultiviewCreateInfoKHX: return "RenderPassMultiviewCreateInfoKHX"; - case StructureType::ePhysicalDeviceMultiviewFeaturesKHX: return "PhysicalDeviceMultiviewFeaturesKHX"; - case StructureType::ePhysicalDeviceMultiviewPropertiesKHX: return "PhysicalDeviceMultiviewPropertiesKHX"; - case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV"; - case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV"; - case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV"; - case StructureType::eExportMemoryWin32HandleInfoNV: return "ExportMemoryWin32HandleInfoNV"; - case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV"; - case StructureType::ePhysicalDeviceFeatures2KHR: return "PhysicalDeviceFeatures2KHR"; - case StructureType::ePhysicalDeviceProperties2KHR: return "PhysicalDeviceProperties2KHR"; - case StructureType::eFormatProperties2KHR: return "FormatProperties2KHR"; - case StructureType::eImageFormatProperties2KHR: return "ImageFormatProperties2KHR"; - case StructureType::ePhysicalDeviceImageFormatInfo2KHR: return "PhysicalDeviceImageFormatInfo2KHR"; - case StructureType::eQueueFamilyProperties2KHR: return "QueueFamilyProperties2KHR"; - case StructureType::ePhysicalDeviceMemoryProperties2KHR: return "PhysicalDeviceMemoryProperties2KHR"; - case StructureType::eSparseImageFormatProperties2KHR: return "SparseImageFormatProperties2KHR"; - case StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR: return "PhysicalDeviceSparseImageFormatInfo2KHR"; - case StructureType::eMemoryAllocateFlagsInfoKHX: return "MemoryAllocateFlagsInfoKHX"; - case StructureType::eDeviceGroupRenderPassBeginInfoKHX: return "DeviceGroupRenderPassBeginInfoKHX"; - case StructureType::eDeviceGroupCommandBufferBeginInfoKHX: return "DeviceGroupCommandBufferBeginInfoKHX"; - case StructureType::eDeviceGroupSubmitInfoKHX: return "DeviceGroupSubmitInfoKHX"; - case StructureType::eDeviceGroupBindSparseInfoKHX: return "DeviceGroupBindSparseInfoKHX"; - case StructureType::eAcquireNextImageInfoKHX: return "AcquireNextImageInfoKHX"; - case StructureType::eBindBufferMemoryDeviceGroupInfoKHX: return "BindBufferMemoryDeviceGroupInfoKHX"; - case StructureType::eBindImageMemoryDeviceGroupInfoKHX: return "BindImageMemoryDeviceGroupInfoKHX"; - case StructureType::eDeviceGroupPresentCapabilitiesKHX: return "DeviceGroupPresentCapabilitiesKHX"; - case StructureType::eImageSwapchainCreateInfoKHX: return "ImageSwapchainCreateInfoKHX"; - case StructureType::eBindImageMemorySwapchainInfoKHX: return "BindImageMemorySwapchainInfoKHX"; - case StructureType::eDeviceGroupPresentInfoKHX: return "DeviceGroupPresentInfoKHX"; - case StructureType::eDeviceGroupSwapchainCreateInfoKHX: return "DeviceGroupSwapchainCreateInfoKHX"; - case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT"; - case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN"; - case StructureType::ePhysicalDeviceGroupPropertiesKHX: return "PhysicalDeviceGroupPropertiesKHX"; - case StructureType::eDeviceGroupDeviceCreateInfoKHX: return "DeviceGroupDeviceCreateInfoKHX"; - case StructureType::ePhysicalDeviceExternalImageFormatInfoKHR: return "PhysicalDeviceExternalImageFormatInfoKHR"; - case StructureType::eExternalImageFormatPropertiesKHR: return "ExternalImageFormatPropertiesKHR"; - case StructureType::ePhysicalDeviceExternalBufferInfoKHR: return "PhysicalDeviceExternalBufferInfoKHR"; - case StructureType::eExternalBufferPropertiesKHR: return "ExternalBufferPropertiesKHR"; - case StructureType::ePhysicalDeviceIdPropertiesKHR: return "PhysicalDeviceIdPropertiesKHR"; - case StructureType::eExternalMemoryBufferCreateInfoKHR: return "ExternalMemoryBufferCreateInfoKHR"; - case StructureType::eExternalMemoryImageCreateInfoKHR: return "ExternalMemoryImageCreateInfoKHR"; - case StructureType::eExportMemoryAllocateInfoKHR: return "ExportMemoryAllocateInfoKHR"; - case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR"; - case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR"; - case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR"; - case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR"; - case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR"; - case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR"; - case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR"; - case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR"; - case StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR: return "PhysicalDeviceExternalSemaphoreInfoKHR"; - case StructureType::eExternalSemaphorePropertiesKHR: return "ExternalSemaphorePropertiesKHR"; - case StructureType::eExportSemaphoreCreateInfoKHR: return "ExportSemaphoreCreateInfoKHR"; - case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR"; - case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR"; - case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR"; - case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR"; - case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR"; - case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR"; - case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR"; - case StructureType::ePhysicalDevice16BitStorageFeaturesKHR: return "PhysicalDevice16BitStorageFeaturesKHR"; - case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR"; - case StructureType::eDescriptorUpdateTemplateCreateInfoKHR: return "DescriptorUpdateTemplateCreateInfoKHR"; - case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX"; - case StructureType::eIndirectCommandsLayoutCreateInfoNVX: return "IndirectCommandsLayoutCreateInfoNVX"; - case StructureType::eCmdProcessCommandsInfoNVX: return "CmdProcessCommandsInfoNVX"; - case StructureType::eCmdReserveSpaceForCommandsInfoNVX: return "CmdReserveSpaceForCommandsInfoNVX"; - case StructureType::eDeviceGeneratedCommandsLimitsNVX: return "DeviceGeneratedCommandsLimitsNVX"; - case StructureType::eDeviceGeneratedCommandsFeaturesNVX: return "DeviceGeneratedCommandsFeaturesNVX"; - case StructureType::ePipelineViewportWScalingStateCreateInfoNV: return "PipelineViewportWScalingStateCreateInfoNV"; - case StructureType::eSurfaceCapabilities2EXT: return "SurfaceCapabilities2EXT"; - case StructureType::eDisplayPowerInfoEXT: return "DisplayPowerInfoEXT"; - case StructureType::eDeviceEventInfoEXT: return "DeviceEventInfoEXT"; - case StructureType::eDisplayEventInfoEXT: return "DisplayEventInfoEXT"; - case StructureType::eSwapchainCounterCreateInfoEXT: return "SwapchainCounterCreateInfoEXT"; - case StructureType::ePresentTimesInfoGOOGLE: return "PresentTimesInfoGOOGLE"; - case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"; - case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV"; - case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT"; - case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT: return "PhysicalDeviceConservativeRasterizationPropertiesEXT"; - case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT: return "PipelineRasterizationConservativeStateCreateInfoEXT"; - case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT"; - case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR"; - case StructureType::ePhysicalDeviceExternalFenceInfoKHR: return "PhysicalDeviceExternalFenceInfoKHR"; - case StructureType::eExternalFencePropertiesKHR: return "ExternalFencePropertiesKHR"; - case StructureType::eExportFenceCreateInfoKHR: return "ExportFenceCreateInfoKHR"; - case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR"; - case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR"; - case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR"; - case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR"; - case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR"; - case StructureType::ePhysicalDevicePointClippingPropertiesKHR: return "PhysicalDevicePointClippingPropertiesKHR"; - case StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR: return "RenderPassInputAttachmentAspectCreateInfoKHR"; - case StructureType::eImageViewUsageCreateInfoKHR: return "ImageViewUsageCreateInfoKHR"; - case StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR: return "PipelineTessellationDomainOriginStateCreateInfoKHR"; - case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR"; - case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR"; - case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR"; - case StructureType::ePhysicalDeviceVariablePointerFeaturesKHR: return "PhysicalDeviceVariablePointerFeaturesKHR"; - case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK"; - case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK"; - case StructureType::eMemoryDedicatedRequirementsKHR: return "MemoryDedicatedRequirementsKHR"; - case StructureType::eMemoryDedicatedAllocateInfoKHR: return "MemoryDedicatedAllocateInfoKHR"; - case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT"; - case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT"; - case StructureType::eSampleLocationsInfoEXT: return "SampleLocationsInfoEXT"; - case StructureType::eRenderPassSampleLocationsBeginInfoEXT: return "RenderPassSampleLocationsBeginInfoEXT"; - case StructureType::ePipelineSampleLocationsStateCreateInfoEXT: return "PipelineSampleLocationsStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT: return "PhysicalDeviceSampleLocationsPropertiesEXT"; - case StructureType::eMultisamplePropertiesEXT: return "MultisamplePropertiesEXT"; - case StructureType::eBufferMemoryRequirementsInfo2KHR: return "BufferMemoryRequirementsInfo2KHR"; - case StructureType::eImageMemoryRequirementsInfo2KHR: return "ImageMemoryRequirementsInfo2KHR"; - case StructureType::eImageSparseMemoryRequirementsInfo2KHR: return "ImageSparseMemoryRequirementsInfo2KHR"; - case StructureType::eMemoryRequirements2KHR: return "MemoryRequirements2KHR"; - case StructureType::eSparseImageMemoryRequirements2KHR: return "SparseImageMemoryRequirements2KHR"; - case StructureType::eImageFormatListCreateInfoKHR: return "ImageFormatListCreateInfoKHR"; - case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT"; - case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT"; - case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT"; - case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV"; - case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV"; - case StructureType::eSamplerYcbcrConversionCreateInfoKHR: return "SamplerYcbcrConversionCreateInfoKHR"; - case StructureType::eSamplerYcbcrConversionInfoKHR: return "SamplerYcbcrConversionInfoKHR"; - case StructureType::eBindImagePlaneMemoryInfoKHR: return "BindImagePlaneMemoryInfoKHR"; - case StructureType::eImagePlaneMemoryRequirementsInfoKHR: return "ImagePlaneMemoryRequirementsInfoKHR"; - case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR: return "PhysicalDeviceSamplerYcbcrConversionFeaturesKHR"; - case StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR: return "SamplerYcbcrConversionImageFormatPropertiesKHR"; - case StructureType::eBindBufferMemoryInfoKHR: return "BindBufferMemoryInfoKHR"; - case StructureType::eBindImageMemoryInfoKHR: return "BindImageMemoryInfoKHR"; - case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT"; - case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT"; - case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT"; - case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT"; - case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT"; - case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubpassContents value) - { - switch (value) - { - case SubpassContents::eInline: return "Inline"; - case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DynamicState value) - { - switch (value) - { - case DynamicState::eViewport: return "Viewport"; - case DynamicState::eScissor: return "Scissor"; - case DynamicState::eLineWidth: return "LineWidth"; - case DynamicState::eDepthBias: return "DepthBias"; - case DynamicState::eBlendConstants: return "BlendConstants"; - case DynamicState::eDepthBounds: return "DepthBounds"; - case DynamicState::eStencilCompareMask: return "StencilCompareMask"; - case DynamicState::eStencilWriteMask: return "StencilWriteMask"; - case DynamicState::eStencilReference: return "StencilReference"; - case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV"; - case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT"; - case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateTypeKHR value) - { - switch (value) - { - case DescriptorUpdateTemplateTypeKHR::eDescriptorSet: return "DescriptorSet"; - case DescriptorUpdateTemplateTypeKHR::ePushDescriptors: return "PushDescriptors"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ObjectType value) - { - switch (value) - { - case ObjectType::eUnknown: return "Unknown"; - case ObjectType::eInstance: return "Instance"; - case ObjectType::ePhysicalDevice: return "PhysicalDevice"; - case ObjectType::eDevice: return "Device"; - case ObjectType::eQueue: return "Queue"; - case ObjectType::eSemaphore: return "Semaphore"; - case ObjectType::eCommandBuffer: return "CommandBuffer"; - case ObjectType::eFence: return "Fence"; - case ObjectType::eDeviceMemory: return "DeviceMemory"; - case ObjectType::eBuffer: return "Buffer"; - case ObjectType::eImage: return "Image"; - case ObjectType::eEvent: return "Event"; - case ObjectType::eQueryPool: return "QueryPool"; - case ObjectType::eBufferView: return "BufferView"; - case ObjectType::eImageView: return "ImageView"; - case ObjectType::eShaderModule: return "ShaderModule"; - case ObjectType::ePipelineCache: return "PipelineCache"; - case ObjectType::ePipelineLayout: return "PipelineLayout"; - case ObjectType::eRenderPass: return "RenderPass"; - case ObjectType::ePipeline: return "Pipeline"; - case ObjectType::eDescriptorSetLayout: return "DescriptorSetLayout"; - case ObjectType::eSampler: return "Sampler"; - case ObjectType::eDescriptorPool: return "DescriptorPool"; - case ObjectType::eDescriptorSet: return "DescriptorSet"; - case ObjectType::eFramebuffer: return "Framebuffer"; - case ObjectType::eCommandPool: return "CommandPool"; - case ObjectType::eSurfaceKHR: return "SurfaceKHR"; - case ObjectType::eSwapchainKHR: return "SwapchainKHR"; - case ObjectType::eDisplayKHR: return "DisplayKHR"; - case ObjectType::eDisplayModeKHR: return "DisplayModeKHR"; - case ObjectType::eDebugReportCallbackEXT: return "DebugReportCallbackEXT"; - case ObjectType::eDescriptorUpdateTemplateKHR: return "DescriptorUpdateTemplateKHR"; - case ObjectType::eObjectTableNVX: return "ObjectTableNVX"; - case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX"; - case ObjectType::eSamplerYcbcrConversionKHR: return "SamplerYcbcrConversionKHR"; - case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value) - { - switch (value) - { - case QueueFlagBits::eGraphics: return "Graphics"; - case QueueFlagBits::eCompute: return "Compute"; - case QueueFlagBits::eTransfer: return "Transfer"; - case QueueFlagBits::eSparseBinding: return "SparseBinding"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueueFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueueFlagBits::eGraphics) result += "Graphics | "; - if (value & QueueFlagBits::eCompute) result += "Compute | "; - if (value & QueueFlagBits::eTransfer) result += "Transfer | "; - if (value & QueueFlagBits::eSparseBinding) result += "SparseBinding | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlagBits value) - { - switch (value) - { - case MemoryPropertyFlagBits::eDeviceLocal: return "DeviceLocal"; - case MemoryPropertyFlagBits::eHostVisible: return "HostVisible"; - case MemoryPropertyFlagBits::eHostCoherent: return "HostCoherent"; - case MemoryPropertyFlagBits::eHostCached: return "HostCached"; - case MemoryPropertyFlagBits::eLazilyAllocated: return "LazilyAllocated"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & MemoryPropertyFlagBits::eDeviceLocal) result += "DeviceLocal | "; - if (value & MemoryPropertyFlagBits::eHostVisible) result += "HostVisible | "; - if (value & MemoryPropertyFlagBits::eHostCoherent) result += "HostCoherent | "; - if (value & MemoryPropertyFlagBits::eHostCached) result += "HostCached | "; - if (value & MemoryPropertyFlagBits::eLazilyAllocated) result += "LazilyAllocated | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlagBits value) - { - switch (value) - { - case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal"; - case MemoryHeapFlagBits::eMultiInstanceKHX: return "MultiInstanceKHX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | "; - if (value & MemoryHeapFlagBits::eMultiInstanceKHX) result += "MultiInstanceKHX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(AccessFlagBits value) - { - switch (value) - { - case AccessFlagBits::eIndirectCommandRead: return "IndirectCommandRead"; - case AccessFlagBits::eIndexRead: return "IndexRead"; - case AccessFlagBits::eVertexAttributeRead: return "VertexAttributeRead"; - case AccessFlagBits::eUniformRead: return "UniformRead"; - case AccessFlagBits::eInputAttachmentRead: return "InputAttachmentRead"; - case AccessFlagBits::eShaderRead: return "ShaderRead"; - case AccessFlagBits::eShaderWrite: return "ShaderWrite"; - case AccessFlagBits::eColorAttachmentRead: return "ColorAttachmentRead"; - case AccessFlagBits::eColorAttachmentWrite: return "ColorAttachmentWrite"; - case AccessFlagBits::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead"; - case AccessFlagBits::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite"; - case AccessFlagBits::eTransferRead: return "TransferRead"; - case AccessFlagBits::eTransferWrite: return "TransferWrite"; - case AccessFlagBits::eHostRead: return "HostRead"; - case AccessFlagBits::eHostWrite: return "HostWrite"; - case AccessFlagBits::eMemoryRead: return "MemoryRead"; - case AccessFlagBits::eMemoryWrite: return "MemoryWrite"; - case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX"; - case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX"; - case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AccessFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & AccessFlagBits::eIndirectCommandRead) result += "IndirectCommandRead | "; - if (value & AccessFlagBits::eIndexRead) result += "IndexRead | "; - if (value & AccessFlagBits::eVertexAttributeRead) result += "VertexAttributeRead | "; - if (value & AccessFlagBits::eUniformRead) result += "UniformRead | "; - if (value & AccessFlagBits::eInputAttachmentRead) result += "InputAttachmentRead | "; - if (value & AccessFlagBits::eShaderRead) result += "ShaderRead | "; - if (value & AccessFlagBits::eShaderWrite) result += "ShaderWrite | "; - if (value & AccessFlagBits::eColorAttachmentRead) result += "ColorAttachmentRead | "; - if (value & AccessFlagBits::eColorAttachmentWrite) result += "ColorAttachmentWrite | "; - if (value & AccessFlagBits::eDepthStencilAttachmentRead) result += "DepthStencilAttachmentRead | "; - if (value & AccessFlagBits::eDepthStencilAttachmentWrite) result += "DepthStencilAttachmentWrite | "; - if (value & AccessFlagBits::eTransferRead) result += "TransferRead | "; - if (value & AccessFlagBits::eTransferWrite) result += "TransferWrite | "; - if (value & AccessFlagBits::eHostRead) result += "HostRead | "; - if (value & AccessFlagBits::eHostWrite) result += "HostWrite | "; - if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | "; - if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | "; - if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | "; - if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | "; - if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferUsageFlagBits value) - { - switch (value) - { - case BufferUsageFlagBits::eTransferSrc: return "TransferSrc"; - case BufferUsageFlagBits::eTransferDst: return "TransferDst"; - case BufferUsageFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer"; - case BufferUsageFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer"; - case BufferUsageFlagBits::eUniformBuffer: return "UniformBuffer"; - case BufferUsageFlagBits::eStorageBuffer: return "StorageBuffer"; - case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer"; - case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer"; - case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BufferUsageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & BufferUsageFlagBits::eTransferSrc) result += "TransferSrc | "; - if (value & BufferUsageFlagBits::eTransferDst) result += "TransferDst | "; - if (value & BufferUsageFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | "; - if (value & BufferUsageFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | "; - if (value & BufferUsageFlagBits::eUniformBuffer) result += "UniformBuffer | "; - if (value & BufferUsageFlagBits::eStorageBuffer) result += "StorageBuffer | "; - if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | "; - if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | "; - if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(BufferCreateFlagBits value) - { - switch (value) - { - case BufferCreateFlagBits::eSparseBinding: return "SparseBinding"; - case BufferCreateFlagBits::eSparseResidency: return "SparseResidency"; - case BufferCreateFlagBits::eSparseAliased: return "SparseAliased"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BufferCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & BufferCreateFlagBits::eSparseBinding) result += "SparseBinding | "; - if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | "; - if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ShaderStageFlagBits value) - { - switch (value) - { - case ShaderStageFlagBits::eVertex: return "Vertex"; - case ShaderStageFlagBits::eTessellationControl: return "TessellationControl"; - case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation"; - case ShaderStageFlagBits::eGeometry: return "Geometry"; - case ShaderStageFlagBits::eFragment: return "Fragment"; - case ShaderStageFlagBits::eCompute: return "Compute"; - case ShaderStageFlagBits::eAllGraphics: return "AllGraphics"; - case ShaderStageFlagBits::eAll: return "All"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ShaderStageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ShaderStageFlagBits::eVertex) result += "Vertex | "; - if (value & ShaderStageFlagBits::eTessellationControl) result += "TessellationControl | "; - if (value & ShaderStageFlagBits::eTessellationEvaluation) result += "TessellationEvaluation | "; - if (value & ShaderStageFlagBits::eGeometry) result += "Geometry | "; - if (value & ShaderStageFlagBits::eFragment) result += "Fragment | "; - if (value & ShaderStageFlagBits::eCompute) result += "Compute | "; - if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | "; - if (value & ShaderStageFlagBits::eAll) result += "All | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageUsageFlagBits value) - { - switch (value) - { - case ImageUsageFlagBits::eTransferSrc: return "TransferSrc"; - case ImageUsageFlagBits::eTransferDst: return "TransferDst"; - case ImageUsageFlagBits::eSampled: return "Sampled"; - case ImageUsageFlagBits::eStorage: return "Storage"; - case ImageUsageFlagBits::eColorAttachment: return "ColorAttachment"; - case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment"; - case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment"; - case ImageUsageFlagBits::eInputAttachment: return "InputAttachment"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageUsageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ImageUsageFlagBits::eTransferSrc) result += "TransferSrc | "; - if (value & ImageUsageFlagBits::eTransferDst) result += "TransferDst | "; - if (value & ImageUsageFlagBits::eSampled) result += "Sampled | "; - if (value & ImageUsageFlagBits::eStorage) result += "Storage | "; - if (value & ImageUsageFlagBits::eColorAttachment) result += "ColorAttachment | "; - if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | "; - if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | "; - if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageCreateFlagBits value) - { - switch (value) - { - case ImageCreateFlagBits::eSparseBinding: return "SparseBinding"; - case ImageCreateFlagBits::eSparseResidency: return "SparseResidency"; - case ImageCreateFlagBits::eSparseAliased: return "SparseAliased"; - case ImageCreateFlagBits::eMutableFormat: return "MutableFormat"; - case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible"; - case ImageCreateFlagBits::eBindSfrKHX: return "BindSfrKHX"; - case ImageCreateFlagBits::e2DArrayCompatibleKHR: return "2DArrayCompatibleKHR"; - case ImageCreateFlagBits::eBlockTexelViewCompatibleKHR: return "BlockTexelViewCompatibleKHR"; - case ImageCreateFlagBits::eExtendedUsageKHR: return "ExtendedUsageKHR"; - case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT"; - case ImageCreateFlagBits::eDisjointKHR: return "DisjointKHR"; - case ImageCreateFlagBits::eAliasKHR: return "AliasKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ImageCreateFlagBits::eSparseBinding) result += "SparseBinding | "; - if (value & ImageCreateFlagBits::eSparseResidency) result += "SparseResidency | "; - if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | "; - if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | "; - if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | "; - if (value & ImageCreateFlagBits::eBindSfrKHX) result += "BindSfrKHX | "; - if (value & ImageCreateFlagBits::e2DArrayCompatibleKHR) result += "2DArrayCompatibleKHR | "; - if (value & ImageCreateFlagBits::eBlockTexelViewCompatibleKHR) result += "BlockTexelViewCompatibleKHR | "; - if (value & ImageCreateFlagBits::eExtendedUsageKHR) result += "ExtendedUsageKHR | "; - if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | "; - if (value & ImageCreateFlagBits::eDisjointKHR) result += "DisjointKHR | "; - if (value & ImageCreateFlagBits::eAliasKHR) result += "AliasKHR | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlagBits value) - { - switch (value) - { - case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization"; - case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives"; - case PipelineCreateFlagBits::eDerivative: return "Derivative"; - case PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX: return "ViewIndexFromDeviceIndexKHX"; - case PipelineCreateFlagBits::eDispatchBaseKHX: return "DispatchBaseKHX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | "; - if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | "; - if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | "; - if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) result += "ViewIndexFromDeviceIndexKHX | "; - if (value & PipelineCreateFlagBits::eDispatchBaseKHX) result += "DispatchBaseKHX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ColorComponentFlagBits value) - { - switch (value) - { - case ColorComponentFlagBits::eR: return "R"; - case ColorComponentFlagBits::eG: return "G"; - case ColorComponentFlagBits::eB: return "B"; - case ColorComponentFlagBits::eA: return "A"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ColorComponentFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ColorComponentFlagBits::eR) result += "R | "; - if (value & ColorComponentFlagBits::eG) result += "G | "; - if (value & ColorComponentFlagBits::eB) result += "B | "; - if (value & ColorComponentFlagBits::eA) result += "A | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FenceCreateFlagBits value) - { - switch (value) - { - case FenceCreateFlagBits::eSignaled: return "Signaled"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(FenceCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & FenceCreateFlagBits::eSignaled) result += "Signaled | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlagBits value) - { - switch (value) - { - case FormatFeatureFlagBits::eSampledImage: return "SampledImage"; - case FormatFeatureFlagBits::eStorageImage: return "StorageImage"; - case FormatFeatureFlagBits::eStorageImageAtomic: return "StorageImageAtomic"; - case FormatFeatureFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer"; - case FormatFeatureFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer"; - case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "StorageTexelBufferAtomic"; - case FormatFeatureFlagBits::eVertexBuffer: return "VertexBuffer"; - case FormatFeatureFlagBits::eColorAttachment: return "ColorAttachment"; - case FormatFeatureFlagBits::eColorAttachmentBlend: return "ColorAttachmentBlend"; - case FormatFeatureFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment"; - case FormatFeatureFlagBits::eBlitSrc: return "BlitSrc"; - case FormatFeatureFlagBits::eBlitDst: return "BlitDst"; - case FormatFeatureFlagBits::eSampledImageFilterLinear: return "SampledImageFilterLinear"; - case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG"; - case FormatFeatureFlagBits::eTransferSrcKHR: return "TransferSrcKHR"; - case FormatFeatureFlagBits::eTransferDstKHR: return "TransferDstKHR"; - case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT"; - case FormatFeatureFlagBits::eMidpointChromaSamplesKHR: return "MidpointChromaSamplesKHR"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilterKHR: return "SampledImageYcbcrConversionLinearFilterKHR"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilterKHR: return "SampledImageYcbcrConversionSeparateReconstructionFilterKHR"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitKHR: return "SampledImageYcbcrConversionChromaReconstructionExplicitKHR"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR: return "SampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR"; - case FormatFeatureFlagBits::eDisjointKHR: return "DisjointKHR"; - case FormatFeatureFlagBits::eCositedChromaSamplesKHR: return "CositedChromaSamplesKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & FormatFeatureFlagBits::eSampledImage) result += "SampledImage | "; - if (value & FormatFeatureFlagBits::eStorageImage) result += "StorageImage | "; - if (value & FormatFeatureFlagBits::eStorageImageAtomic) result += "StorageImageAtomic | "; - if (value & FormatFeatureFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | "; - if (value & FormatFeatureFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | "; - if (value & FormatFeatureFlagBits::eStorageTexelBufferAtomic) result += "StorageTexelBufferAtomic | "; - if (value & FormatFeatureFlagBits::eVertexBuffer) result += "VertexBuffer | "; - if (value & FormatFeatureFlagBits::eColorAttachment) result += "ColorAttachment | "; - if (value & FormatFeatureFlagBits::eColorAttachmentBlend) result += "ColorAttachmentBlend | "; - if (value & FormatFeatureFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | "; - if (value & FormatFeatureFlagBits::eBlitSrc) result += "BlitSrc | "; - if (value & FormatFeatureFlagBits::eBlitDst) result += "BlitDst | "; - if (value & FormatFeatureFlagBits::eSampledImageFilterLinear) result += "SampledImageFilterLinear | "; - if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | "; - if (value & FormatFeatureFlagBits::eTransferSrcKHR) result += "TransferSrcKHR | "; - if (value & FormatFeatureFlagBits::eTransferDstKHR) result += "TransferDstKHR | "; - if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | "; - if (value & FormatFeatureFlagBits::eMidpointChromaSamplesKHR) result += "MidpointChromaSamplesKHR | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilterKHR) result += "SampledImageYcbcrConversionLinearFilterKHR | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilterKHR) result += "SampledImageYcbcrConversionSeparateReconstructionFilterKHR | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitKHR) result += "SampledImageYcbcrConversionChromaReconstructionExplicitKHR | "; - if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR | "; - if (value & FormatFeatureFlagBits::eDisjointKHR) result += "DisjointKHR | "; - if (value & FormatFeatureFlagBits::eCositedChromaSamplesKHR) result += "CositedChromaSamplesKHR | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryControlFlagBits value) - { - switch (value) - { - case QueryControlFlagBits::ePrecise: return "Precise"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryControlFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueryControlFlagBits::ePrecise) result += "Precise | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryResultFlagBits value) - { - switch (value) - { - case QueryResultFlagBits::e64: return "64"; - case QueryResultFlagBits::eWait: return "Wait"; - case QueryResultFlagBits::eWithAvailability: return "WithAvailability"; - case QueryResultFlagBits::ePartial: return "Partial"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryResultFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueryResultFlagBits::e64) result += "64 | "; - if (value & QueryResultFlagBits::eWait) result += "Wait | "; - if (value & QueryResultFlagBits::eWithAvailability) result += "WithAvailability | "; - if (value & QueryResultFlagBits::ePartial) result += "Partial | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlagBits value) - { - switch (value) - { - case CommandBufferUsageFlagBits::eOneTimeSubmit: return "OneTimeSubmit"; - case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue"; - case CommandBufferUsageFlagBits::eSimultaneousUse: return "SimultaneousUse"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandBufferUsageFlagBits::eOneTimeSubmit) result += "OneTimeSubmit | "; - if (value & CommandBufferUsageFlagBits::eRenderPassContinue) result += "RenderPassContinue | "; - if (value & CommandBufferUsageFlagBits::eSimultaneousUse) result += "SimultaneousUse | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlagBits value) - { - switch (value) - { - case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "InputAssemblyVertices"; - case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "InputAssemblyPrimitives"; - case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "VertexShaderInvocations"; - case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "GeometryShaderInvocations"; - case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "GeometryShaderPrimitives"; - case QueryPipelineStatisticFlagBits::eClippingInvocations: return "ClippingInvocations"; - case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "ClippingPrimitives"; - case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "FragmentShaderInvocations"; - case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches"; - case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations"; - case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices) result += "InputAssemblyVertices | "; - if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) result += "InputAssemblyPrimitives | "; - if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations) result += "VertexShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) result += "GeometryShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) result += "GeometryShaderPrimitives | "; - if (value & QueryPipelineStatisticFlagBits::eClippingInvocations) result += "ClippingInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives) result += "ClippingPrimitives | "; - if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) result += "FragmentShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) result += "TessellationControlShaderPatches | "; - if (value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) result += "TessellationEvaluationShaderInvocations | "; - if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations) result += "ComputeShaderInvocations | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ImageAspectFlagBits value) - { - switch (value) - { - case ImageAspectFlagBits::eColor: return "Color"; - case ImageAspectFlagBits::eDepth: return "Depth"; - case ImageAspectFlagBits::eStencil: return "Stencil"; - case ImageAspectFlagBits::eMetadata: return "Metadata"; - case ImageAspectFlagBits::ePlane0KHR: return "Plane0KHR"; - case ImageAspectFlagBits::ePlane1KHR: return "Plane1KHR"; - case ImageAspectFlagBits::ePlane2KHR: return "Plane2KHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ImageAspectFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & ImageAspectFlagBits::eColor) result += "Color | "; - if (value & ImageAspectFlagBits::eDepth) result += "Depth | "; - if (value & ImageAspectFlagBits::eStencil) result += "Stencil | "; - if (value & ImageAspectFlagBits::eMetadata) result += "Metadata | "; - if (value & ImageAspectFlagBits::ePlane0KHR) result += "Plane0KHR | "; - if (value & ImageAspectFlagBits::ePlane1KHR) result += "Plane1KHR | "; - if (value & ImageAspectFlagBits::ePlane2KHR) result += "Plane2KHR | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlagBits value) - { - switch (value) - { - case SparseImageFormatFlagBits::eSingleMiptail: return "SingleMiptail"; - case SparseImageFormatFlagBits::eAlignedMipSize: return "AlignedMipSize"; - case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SparseImageFormatFlagBits::eSingleMiptail) result += "SingleMiptail | "; - if (value & SparseImageFormatFlagBits::eAlignedMipSize) result += "AlignedMipSize | "; - if (value & SparseImageFormatFlagBits::eNonstandardBlockSize) result += "NonstandardBlockSize | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlagBits value) - { - switch (value) - { - case SparseMemoryBindFlagBits::eMetadata: return "Metadata"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SparseMemoryBindFlagBits::eMetadata) result += "Metadata | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits value) - { - switch (value) - { - case PipelineStageFlagBits::eTopOfPipe: return "TopOfPipe"; - case PipelineStageFlagBits::eDrawIndirect: return "DrawIndirect"; - case PipelineStageFlagBits::eVertexInput: return "VertexInput"; - case PipelineStageFlagBits::eVertexShader: return "VertexShader"; - case PipelineStageFlagBits::eTessellationControlShader: return "TessellationControlShader"; - case PipelineStageFlagBits::eTessellationEvaluationShader: return "TessellationEvaluationShader"; - case PipelineStageFlagBits::eGeometryShader: return "GeometryShader"; - case PipelineStageFlagBits::eFragmentShader: return "FragmentShader"; - case PipelineStageFlagBits::eEarlyFragmentTests: return "EarlyFragmentTests"; - case PipelineStageFlagBits::eLateFragmentTests: return "LateFragmentTests"; - case PipelineStageFlagBits::eColorAttachmentOutput: return "ColorAttachmentOutput"; - case PipelineStageFlagBits::eComputeShader: return "ComputeShader"; - case PipelineStageFlagBits::eTransfer: return "Transfer"; - case PipelineStageFlagBits::eBottomOfPipe: return "BottomOfPipe"; - case PipelineStageFlagBits::eHost: return "Host"; - case PipelineStageFlagBits::eAllGraphics: return "AllGraphics"; - case PipelineStageFlagBits::eAllCommands: return "AllCommands"; - case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PipelineStageFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & PipelineStageFlagBits::eTopOfPipe) result += "TopOfPipe | "; - if (value & PipelineStageFlagBits::eDrawIndirect) result += "DrawIndirect | "; - if (value & PipelineStageFlagBits::eVertexInput) result += "VertexInput | "; - if (value & PipelineStageFlagBits::eVertexShader) result += "VertexShader | "; - if (value & PipelineStageFlagBits::eTessellationControlShader) result += "TessellationControlShader | "; - if (value & PipelineStageFlagBits::eTessellationEvaluationShader) result += "TessellationEvaluationShader | "; - if (value & PipelineStageFlagBits::eGeometryShader) result += "GeometryShader | "; - if (value & PipelineStageFlagBits::eFragmentShader) result += "FragmentShader | "; - if (value & PipelineStageFlagBits::eEarlyFragmentTests) result += "EarlyFragmentTests | "; - if (value & PipelineStageFlagBits::eLateFragmentTests) result += "LateFragmentTests | "; - if (value & PipelineStageFlagBits::eColorAttachmentOutput) result += "ColorAttachmentOutput | "; - if (value & PipelineStageFlagBits::eComputeShader) result += "ComputeShader | "; - if (value & PipelineStageFlagBits::eTransfer) result += "Transfer | "; - if (value & PipelineStageFlagBits::eBottomOfPipe) result += "BottomOfPipe | "; - if (value & PipelineStageFlagBits::eHost) result += "Host | "; - if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | "; - if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | "; - if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlagBits value) - { - switch (value) - { - case CommandPoolCreateFlagBits::eTransient: return "Transient"; - case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandPoolCreateFlagBits::eTransient) result += "Transient | "; - if (value & CommandPoolCreateFlagBits::eResetCommandBuffer) result += "ResetCommandBuffer | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlagBits value) - { - switch (value) - { - case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandPoolResetFlagBits::eReleaseResources) result += "ReleaseResources | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlagBits value) - { - switch (value) - { - case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & CommandBufferResetFlagBits::eReleaseResources) result += "ReleaseResources | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SampleCountFlagBits value) - { - switch (value) - { - case SampleCountFlagBits::e1: return "1"; - case SampleCountFlagBits::e2: return "2"; - case SampleCountFlagBits::e4: return "4"; - case SampleCountFlagBits::e8: return "8"; - case SampleCountFlagBits::e16: return "16"; - case SampleCountFlagBits::e32: return "32"; - case SampleCountFlagBits::e64: return "64"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SampleCountFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SampleCountFlagBits::e1) result += "1 | "; - if (value & SampleCountFlagBits::e2) result += "2 | "; - if (value & SampleCountFlagBits::e4) result += "4 | "; - if (value & SampleCountFlagBits::e8) result += "8 | "; - if (value & SampleCountFlagBits::e16) result += "16 | "; - if (value & SampleCountFlagBits::e32) result += "32 | "; - if (value & SampleCountFlagBits::e64) result += "64 | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlagBits value) - { - switch (value) - { - case AttachmentDescriptionFlagBits::eMayAlias: return "MayAlias"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & AttachmentDescriptionFlagBits::eMayAlias) result += "MayAlias | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(StencilFaceFlagBits value) - { - switch (value) - { - case StencilFaceFlagBits::eFront: return "Front"; - case StencilFaceFlagBits::eBack: return "Back"; - case StencilFaceFlagBits::eVkStencilFrontAndBack: return "VkStencilFrontAndBack"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(StencilFaceFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & StencilFaceFlagBits::eFront) result += "Front | "; - if (value & StencilFaceFlagBits::eBack) result += "Back | "; - if (value & StencilFaceFlagBits::eVkStencilFrontAndBack) result += "VkStencilFrontAndBack | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlagBits value) - { - switch (value) - { - case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet) result += "FreeDescriptorSet | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DependencyFlagBits value) - { - switch (value) - { - case DependencyFlagBits::eByRegion: return "ByRegion"; - case DependencyFlagBits::eViewLocalKHX: return "ViewLocalKHX"; - case DependencyFlagBits::eDeviceGroupKHX: return "DeviceGroupKHX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DependencyFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & DependencyFlagBits::eByRegion) result += "ByRegion | "; - if (value & DependencyFlagBits::eViewLocalKHX) result += "ViewLocalKHX | "; - if (value & DependencyFlagBits::eDeviceGroupKHX) result += "DeviceGroupKHX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PresentModeKHR value) - { - switch (value) - { - case PresentModeKHR::eImmediate: return "Immediate"; - case PresentModeKHR::eMailbox: return "Mailbox"; - case PresentModeKHR::eFifo: return "Fifo"; - case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed"; - case PresentModeKHR::eSharedDemandRefresh: return "SharedDemandRefresh"; - case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ColorSpaceKHR value) - { - switch (value) - { - case ColorSpaceKHR::eSrgbNonlinear: return "SrgbNonlinear"; - case ColorSpaceKHR::eDisplayP3NonlinearEXT: return "DisplayP3NonlinearEXT"; - case ColorSpaceKHR::eExtendedSrgbLinearEXT: return "ExtendedSrgbLinearEXT"; - case ColorSpaceKHR::eDciP3LinearEXT: return "DciP3LinearEXT"; - case ColorSpaceKHR::eDciP3NonlinearEXT: return "DciP3NonlinearEXT"; - case ColorSpaceKHR::eBt709LinearEXT: return "Bt709LinearEXT"; - case ColorSpaceKHR::eBt709NonlinearEXT: return "Bt709NonlinearEXT"; - case ColorSpaceKHR::eBt2020LinearEXT: return "Bt2020LinearEXT"; - case ColorSpaceKHR::eHdr10St2084EXT: return "Hdr10St2084EXT"; - case ColorSpaceKHR::eDolbyvisionEXT: return "DolbyvisionEXT"; - case ColorSpaceKHR::eHdr10HlgEXT: return "Hdr10HlgEXT"; - case ColorSpaceKHR::eAdobergbLinearEXT: return "AdobergbLinearEXT"; - case ColorSpaceKHR::eAdobergbNonlinearEXT: return "AdobergbNonlinearEXT"; - case ColorSpaceKHR::ePassThroughEXT: return "PassThroughEXT"; - case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagBitsKHR value) - { - switch (value) - { - case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "Opaque"; - case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "Global"; - case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "PerPixel"; - case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque) result += "Opaque | "; - if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal) result += "Global | "; - if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel) result += "PerPixel | "; - if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) result += "PerPixelPremultiplied | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagBitsKHR value) - { - switch (value) - { - case CompositeAlphaFlagBitsKHR::eOpaque: return "Opaque"; - case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "PreMultiplied"; - case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied"; - case CompositeAlphaFlagBitsKHR::eInherit: return "Inherit"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & CompositeAlphaFlagBitsKHR::eOpaque) result += "Opaque | "; - if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied) result += "PreMultiplied | "; - if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied) result += "PostMultiplied | "; - if (value & CompositeAlphaFlagBitsKHR::eInherit) result += "Inherit | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagBitsKHR value) - { - switch (value) - { - case SurfaceTransformFlagBitsKHR::eIdentity: return "Identity"; - case SurfaceTransformFlagBitsKHR::eRotate90: return "Rotate90"; - case SurfaceTransformFlagBitsKHR::eRotate180: return "Rotate180"; - case SurfaceTransformFlagBitsKHR::eRotate270: return "Rotate270"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "HorizontalMirror"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "HorizontalMirrorRotate90"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270"; - case SurfaceTransformFlagBitsKHR::eInherit: return "Inherit"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & SurfaceTransformFlagBitsKHR::eIdentity) result += "Identity | "; - if (value & SurfaceTransformFlagBitsKHR::eRotate90) result += "Rotate90 | "; - if (value & SurfaceTransformFlagBitsKHR::eRotate180) result += "Rotate180 | "; - if (value & SurfaceTransformFlagBitsKHR::eRotate270) result += "Rotate270 | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror) result += "HorizontalMirror | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) result += "HorizontalMirrorRotate90 | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) result += "HorizontalMirrorRotate180 | "; - if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) result += "HorizontalMirrorRotate270 | "; - if (value & SurfaceTransformFlagBitsKHR::eInherit) result += "Inherit | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value) - { - switch (value) - { - case DebugReportFlagBitsEXT::eInformation: return "Information"; - case DebugReportFlagBitsEXT::eWarning: return "Warning"; - case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning"; - case DebugReportFlagBitsEXT::eError: return "Error"; - case DebugReportFlagBitsEXT::eDebug: return "Debug"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DebugReportFlagsEXT value) - { - if (!value) return "{}"; - std::string result; - if (value & DebugReportFlagBitsEXT::eInformation) result += "Information | "; - if (value & DebugReportFlagBitsEXT::eWarning) result += "Warning | "; - if (value & DebugReportFlagBitsEXT::ePerformanceWarning) result += "PerformanceWarning | "; - if (value & DebugReportFlagBitsEXT::eError) result += "Error | "; - if (value & DebugReportFlagBitsEXT::eDebug) result += "Debug | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DebugReportObjectTypeEXT value) - { - switch (value) - { - case DebugReportObjectTypeEXT::eUnknown: return "Unknown"; - case DebugReportObjectTypeEXT::eInstance: return "Instance"; - case DebugReportObjectTypeEXT::ePhysicalDevice: return "PhysicalDevice"; - case DebugReportObjectTypeEXT::eDevice: return "Device"; - case DebugReportObjectTypeEXT::eQueue: return "Queue"; - case DebugReportObjectTypeEXT::eSemaphore: return "Semaphore"; - case DebugReportObjectTypeEXT::eCommandBuffer: return "CommandBuffer"; - case DebugReportObjectTypeEXT::eFence: return "Fence"; - case DebugReportObjectTypeEXT::eDeviceMemory: return "DeviceMemory"; - case DebugReportObjectTypeEXT::eBuffer: return "Buffer"; - case DebugReportObjectTypeEXT::eImage: return "Image"; - case DebugReportObjectTypeEXT::eEvent: return "Event"; - case DebugReportObjectTypeEXT::eQueryPool: return "QueryPool"; - case DebugReportObjectTypeEXT::eBufferView: return "BufferView"; - case DebugReportObjectTypeEXT::eImageView: return "ImageView"; - case DebugReportObjectTypeEXT::eShaderModule: return "ShaderModule"; - case DebugReportObjectTypeEXT::ePipelineCache: return "PipelineCache"; - case DebugReportObjectTypeEXT::ePipelineLayout: return "PipelineLayout"; - case DebugReportObjectTypeEXT::eRenderPass: return "RenderPass"; - case DebugReportObjectTypeEXT::ePipeline: return "Pipeline"; - case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DescriptorSetLayout"; - case DebugReportObjectTypeEXT::eSampler: return "Sampler"; - case DebugReportObjectTypeEXT::eDescriptorPool: return "DescriptorPool"; - case DebugReportObjectTypeEXT::eDescriptorSet: return "DescriptorSet"; - case DebugReportObjectTypeEXT::eFramebuffer: return "Framebuffer"; - case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool"; - case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr"; - case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr"; - case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt"; - case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr"; - case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr"; - case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx"; - case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNvx: return "IndirectCommandsLayoutNvx"; - case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt"; - case DebugReportObjectTypeEXT::eDescriptorUpdateTemplateKHR: return "DescriptorUpdateTemplateKHR"; - case DebugReportObjectTypeEXT::eSamplerYcbcrConversionKHR: return "SamplerYcbcrConversionKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value) - { - switch (value) - { - case RasterizationOrderAMD::eStrict: return "Strict"; - case RasterizationOrderAMD::eRelaxed: return "Relaxed"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsNV value) - { - switch (value) - { - case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32: return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image: return "D3D11Image"; - case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt: return "D3D11ImageKmt"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsNV value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) result += "D3D11Image | "; - if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) result += "D3D11ImageKmt | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsNV value) - { - switch (value) - { - case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBitsNV::eExportable: return "Exportable"; - case ExternalMemoryFeatureFlagBitsNV::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsNV value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) result += "DedicatedOnly | "; - if (value & ExternalMemoryFeatureFlagBitsNV::eExportable) result += "Exportable | "; - if (value & ExternalMemoryFeatureFlagBitsNV::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCheckEXT value) - { - switch (value) - { - case ValidationCheckEXT::eAll: return "All"; - case ValidationCheckEXT::eShaders: return "Shaders"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagBitsNVX value) - { - switch (value) - { - case IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences: return "UnorderedSequences"; - case IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences: return "SparseSequences"; - case IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions: return "EmptyExecutions"; - case IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences: return "IndexedSequences"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagsNVX value) - { - if (!value) return "{}"; - std::string result; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) result += "UnorderedSequences | "; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) result += "SparseSequences | "; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) result += "EmptyExecutions | "; - if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) result += "IndexedSequences | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagBitsNVX value) - { - switch (value) - { - case ObjectEntryUsageFlagBitsNVX::eGraphics: return "Graphics"; - case ObjectEntryUsageFlagBitsNVX::eCompute: return "Compute"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagsNVX value) - { - if (!value) return "{}"; - std::string result; - if (value & ObjectEntryUsageFlagBitsNVX::eGraphics) result += "Graphics | "; - if (value & ObjectEntryUsageFlagBitsNVX::eCompute) result += "Compute | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(IndirectCommandsTokenTypeNVX value) - { - switch (value) - { - case IndirectCommandsTokenTypeNVX::ePipeline: return "Pipeline"; - case IndirectCommandsTokenTypeNVX::eDescriptorSet: return "DescriptorSet"; - case IndirectCommandsTokenTypeNVX::eIndexBuffer: return "IndexBuffer"; - case IndirectCommandsTokenTypeNVX::eVertexBuffer: return "VertexBuffer"; - case IndirectCommandsTokenTypeNVX::ePushConstant: return "PushConstant"; - case IndirectCommandsTokenTypeNVX::eDrawIndexed: return "DrawIndexed"; - case IndirectCommandsTokenTypeNVX::eDraw: return "Draw"; - case IndirectCommandsTokenTypeNVX::eDispatch: return "Dispatch"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ObjectEntryTypeNVX value) - { - switch (value) - { - case ObjectEntryTypeNVX::eDescriptorSet: return "DescriptorSet"; - case ObjectEntryTypeNVX::ePipeline: return "Pipeline"; - case ObjectEntryTypeNVX::eIndexBuffer: return "IndexBuffer"; - case ObjectEntryTypeNVX::eVertexBuffer: return "VertexBuffer"; - case ObjectEntryTypeNVX::ePushConstant: return "PushConstant"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlagBits value) - { - switch (value) - { - case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) result += "PushDescriptorKHR | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsKHR value) - { - switch (value) - { - case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; - case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture: return "D3D11Texture"; - case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt: return "D3D11TextureKmt"; - case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap: return "D3D12Heap"; - case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource: return "D3D12Resource"; - case ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT: return "DmaBufEXT"; - case ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT: return "HostAllocationEXT"; - case ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) result += "D3D11Texture | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) result += "D3D11TextureKmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) result += "D3D12Heap | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) result += "D3D12Resource | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT) result += "DmaBufEXT | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT) result += "HostAllocationEXT | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT) result += "HostMappedForeignMemoryEXT | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsKHR value) - { - switch (value) - { - case ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBitsKHR::eExportable: return "Exportable"; - case ExternalMemoryFeatureFlagBitsKHR::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) result += "DedicatedOnly | "; - if (value & ExternalMemoryFeatureFlagBitsKHR::eExportable) result += "Exportable | "; - if (value & ExternalMemoryFeatureFlagBitsKHR::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBitsKHR value) - { - switch (value) - { - case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; - case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; - case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence: return "D3D12Fence"; - case ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) result += "D3D12Fence | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBitsKHR value) - { - switch (value) - { - case ExternalSemaphoreFeatureFlagBitsKHR::eExportable: return "Exportable"; - case ExternalSemaphoreFeatureFlagBitsKHR::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalSemaphoreFeatureFlagBitsKHR::eExportable) result += "Exportable | "; - if (value & ExternalSemaphoreFeatureFlagBitsKHR::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBitsKHR value) - { - switch (value) - { - case SemaphoreImportFlagBitsKHR::eTemporary: return "Temporary"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & SemaphoreImportFlagBitsKHR::eTemporary) result += "Temporary | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBitsKHR value) - { - switch (value) - { - case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; - case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; - case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalFenceHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalFenceHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBitsKHR value) - { - switch (value) - { - case ExternalFenceFeatureFlagBitsKHR::eExportable: return "Exportable"; - case ExternalFenceFeatureFlagBitsKHR::eImportable: return "Importable"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & ExternalFenceFeatureFlagBitsKHR::eExportable) result += "Exportable | "; - if (value & ExternalFenceFeatureFlagBitsKHR::eImportable) result += "Importable | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBitsKHR value) - { - switch (value) - { - case FenceImportFlagBitsKHR::eTemporary: return "Temporary"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(FenceImportFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & FenceImportFlagBitsKHR::eTemporary) result += "Temporary | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value) - { - switch (value) - { - case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagsEXT value) - { - if (!value) return "{}"; - std::string result; - if (value & SurfaceCounterFlagBitsEXT::eVblank) result += "Vblank | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DisplayPowerStateEXT value) - { - switch (value) - { - case DisplayPowerStateEXT::eOff: return "Off"; - case DisplayPowerStateEXT::eSuspend: return "Suspend"; - case DisplayPowerStateEXT::eOn: return "On"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DeviceEventTypeEXT value) - { - switch (value) - { - case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DisplayEventTypeEXT value) - { - switch (value) - { - case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBitsKHX value) - { - switch (value) - { - case PeerMemoryFeatureFlagBitsKHX::eCopySrc: return "CopySrc"; - case PeerMemoryFeatureFlagBitsKHX::eCopyDst: return "CopyDst"; - case PeerMemoryFeatureFlagBitsKHX::eGenericSrc: return "GenericSrc"; - case PeerMemoryFeatureFlagBitsKHX::eGenericDst: return "GenericDst"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagsKHX value) - { - if (!value) return "{}"; - std::string result; - if (value & PeerMemoryFeatureFlagBitsKHX::eCopySrc) result += "CopySrc | "; - if (value & PeerMemoryFeatureFlagBitsKHX::eCopyDst) result += "CopyDst | "; - if (value & PeerMemoryFeatureFlagBitsKHX::eGenericSrc) result += "GenericSrc | "; - if (value & PeerMemoryFeatureFlagBitsKHX::eGenericDst) result += "GenericDst | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBitsKHX value) - { - switch (value) - { - case MemoryAllocateFlagBitsKHX::eDeviceMask: return "DeviceMask"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagsKHX value) - { - if (!value) return "{}"; - std::string result; - if (value & MemoryAllocateFlagBitsKHX::eDeviceMask) result += "DeviceMask | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagBitsKHX value) - { - switch (value) - { - case DeviceGroupPresentModeFlagBitsKHX::eLocal: return "Local"; - case DeviceGroupPresentModeFlagBitsKHX::eRemote: return "Remote"; - case DeviceGroupPresentModeFlagBitsKHX::eSum: return "Sum"; - case DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice: return "LocalMultiDevice"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHX value) - { - if (!value) return "{}"; - std::string result; - if (value & DeviceGroupPresentModeFlagBitsKHX::eLocal) result += "Local | "; - if (value & DeviceGroupPresentModeFlagBitsKHX::eRemote) result += "Remote | "; - if (value & DeviceGroupPresentModeFlagBitsKHX::eSum) result += "Sum | "; - if (value & DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice) result += "LocalMultiDevice | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagBitsKHR value) - { - switch (value) - { - case SwapchainCreateFlagBitsKHR::eBindSfrKHX: return "BindSfrKHX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value) - { - if (!value) return "{}"; - std::string result; - if (value & SwapchainCreateFlagBitsKHR::eBindSfrKHX) result += "BindSfrKHX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value) - { - switch (value) - { - case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX"; - case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX"; - case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY"; - case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY"; - case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ"; - case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ"; - case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW"; - case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value) - { - switch (value) - { - case DiscardRectangleModeEXT::eInclusive: return "Inclusive"; - case DiscardRectangleModeEXT::eExclusive: return "Exclusive"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value) - { - switch (value) - { - case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX"; - case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value) - { - if (!value) return "{}"; - std::string result; - if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX) result += "PerViewAttributesNVX | "; - if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) result += "PerViewPositionXOnlyNVX | "; - return "{" + result.substr(0, result.size() - 3) + "}"; - } - - VULKAN_HPP_INLINE std::string to_string(PointClippingBehaviorKHR value) - { - switch (value) - { - case PointClippingBehaviorKHR::eAllClipPlanes: return "AllClipPlanes"; - case PointClippingBehaviorKHR::eUserClipPlanesOnly: return "UserClipPlanesOnly"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerReductionModeEXT value) - { - switch (value) - { - case SamplerReductionModeEXT::eWeightedAverage: return "WeightedAverage"; - case SamplerReductionModeEXT::eMin: return "Min"; - case SamplerReductionModeEXT::eMax: return "Max"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(TessellationDomainOriginKHR value) - { - switch (value) - { - case TessellationDomainOriginKHR::eUpperLeft: return "UpperLeft"; - case TessellationDomainOriginKHR::eLowerLeft: return "LowerLeft"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrModelConversionKHR value) - { - switch (value) - { - case SamplerYcbcrModelConversionKHR::eRgbIdentity: return "RgbIdentity"; - case SamplerYcbcrModelConversionKHR::eYcbcrIdentity: return "YcbcrIdentity"; - case SamplerYcbcrModelConversionKHR::eYcbcr709: return "Ycbcr709"; - case SamplerYcbcrModelConversionKHR::eYcbcr601: return "Ycbcr601"; - case SamplerYcbcrModelConversionKHR::eYcbcr2020: return "Ycbcr2020"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrRangeKHR value) - { - switch (value) - { - case SamplerYcbcrRangeKHR::eItuFull: return "ItuFull"; - case SamplerYcbcrRangeKHR::eItuNarrow: return "ItuNarrow"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ChromaLocationKHR value) - { - switch (value) - { - case ChromaLocationKHR::eCositedEven: return "CositedEven"; - case ChromaLocationKHR::eMidpoint: return "Midpoint"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value) - { - switch (value) - { - case BlendOverlapEXT::eUncorrelated: return "Uncorrelated"; - case BlendOverlapEXT::eDisjoint: return "Disjoint"; - case BlendOverlapEXT::eConjoint: return "Conjoint"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value) - { - switch (value) - { - case CoverageModulationModeNV::eNone: return "None"; - case CoverageModulationModeNV::eRgb: return "Rgb"; - case CoverageModulationModeNV::eAlpha: return "Alpha"; - case CoverageModulationModeNV::eRgba: return "Rgba"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ValidationCacheHeaderVersionEXT value) - { - switch (value) - { - case ValidationCacheHeaderVersionEXT::eOne: return "One"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value) - { - switch (value) - { - case ShaderInfoTypeAMD::eStatistics: return "Statistics"; - case ShaderInfoTypeAMD::eBinary: return "Binary"; - case ShaderInfoTypeAMD::eDisassembly: return "Disassembly"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value) - { - switch (value) - { - case QueueGlobalPriorityEXT::eLow: return "Low"; - case QueueGlobalPriorityEXT::eMedium: return "Medium"; - case QueueGlobalPriorityEXT::eHigh: return "High"; - case QueueGlobalPriorityEXT::eRealtime: return "Realtime"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(ConservativeRasterizationModeEXT value) - { - switch (value) - { - case ConservativeRasterizationModeEXT::eDisabled: return "Disabled"; - case ConservativeRasterizationModeEXT::eOverestimate: return "Overestimate"; - case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate"; - default: return "invalid"; - } - } - -} // namespace VULKAN_HPP_NAMESPACE - -#endif |