blob: daaa04d82d8147ede2e0b084e584afffbed3f47a [file] [log] [blame]
// Copyright (c) 2015-2017 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 == 61 , "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
namespace vk
{
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)
{
}
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
#if defined(VULKAN_HPP_NO_EXCEPTIONS) && !defined(VULKAN_HPP_NO_SMART_HANDLE)
# define VULKAN_HPP_NO_SMART_HANDLE
#endif
#ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Type, typename Deleter>
class UniqueHandle
{
public:
explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
: m_value( value )
, m_deleter( deleter )
{}
UniqueHandle( UniqueHandle const& ) = delete;
UniqueHandle( UniqueHandle && other )
: m_value( other.release() )
, m_deleter( std::move( other.m_deleter ) )
{}
~UniqueHandle()
{
destroy();
}
UniqueHandle & operator=( UniqueHandle const& ) = delete;
UniqueHandle & operator=( UniqueHandle && other )
{
reset( other.release() );
m_deleter = std::move( other.m_deleter );
return *this;
}
explicit operator bool() const
{
return m_value.operator bool();
}
Type const* operator->() const
{
return &m_value;
}
Type const& operator*() const
{
return m_value;
}
Type get() const
{
return m_value;
}
Deleter & getDeleter()
{
return m_deleter;
}
Deleter const& getDeleter() const
{
return m_deleter;
}
void reset( Type const& value = Type() )
{
if ( m_value != value )
{
destroy();
m_value = value;
}
}
Type release()
{
Type value = m_value;
m_value = nullptr;
return value;
}
void swap( UniqueHandle<Type, Deleter> & rhs )
{
std::swap(m_value, rhs.m_value);
std::swap(m_deleter, rhs.m_deleter);
}
private:
void destroy()
{
if ( m_value )
{
m_deleter( m_value );
}
}
private:
Type m_value;
Deleter m_deleter;
};
template <typename Type, typename Deleter>
VULKAN_HPP_INLINE void swap( UniqueHandle<Type,Deleter> & lhs, UniqueHandle<Type,Deleter> & rhs )
{
lhs.swap( rhs );
}
#endif
template <typename X, typename Y> constexpr bool isStructureChainValid() { return 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(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>(), "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>(), "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
};
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";
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 "vk::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 ) {}
};
VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
{
assert ( static_cast<long long int>(result) < 0 );
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 );
default: throw SystemError( make_error_code( result ) );
}
}
#endif
} // namespace vk
namespace std
{
template <>
struct is_error_code_enum<vk::Result> : public true_type
{};
}
namespace vk
{
template <typename T>
struct ResultValue
{
ResultValue( Result r, T & v )
: result( r )
, value( 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 );
}
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>;
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!" );