mirror of
https://github.com/KhronosGroup/Vulkan-Hpp.git
synced 2024-10-14 16:32:17 +00:00
Update Vulkan-Headers to v1.3.256 (#1609)
Co-authored-by: GitHub <noreply@github.com>
This commit is contained in:
parent
2613539ff4
commit
c115fd1ec6
@ -1 +1 @@
|
||||
Subproject commit b6a29e5ca865f48368f6b2f170adb89975bb0be1
|
||||
Subproject commit ed857118e243fdc0f3a100f00ac9919e874cfe63
|
@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
|
||||
# include <span>
|
||||
#endif
|
||||
|
||||
static_assert( VK_HEADER_VERSION == 255, "Wrong VK_HEADER_VERSION!" );
|
||||
static_assert( VK_HEADER_VERSION == 256, "Wrong VK_HEADER_VERSION!" );
|
||||
|
||||
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
|
||||
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
|
||||
|
@ -3755,6 +3755,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
|
||||
eTaskShaderEXT = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT,
|
||||
eMeshShaderEXT = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT,
|
||||
eSubpassShaderHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI,
|
||||
eSubpassShadingHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI,
|
||||
eInvocationMaskHUAWEI = VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI,
|
||||
eAccelerationStructureCopyKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR,
|
||||
@ -3786,7 +3787,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
| PipelineStageFlagBits2::eTransformFeedbackEXT | PipelineStageFlagBits2::eConditionalRenderingEXT | PipelineStageFlagBits2::eCommandPreprocessNV |
|
||||
PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits2::eAccelerationStructureBuildKHR |
|
||||
PipelineStageFlagBits2::eRayTracingShaderKHR | PipelineStageFlagBits2::eFragmentDensityProcessEXT | PipelineStageFlagBits2::eTaskShaderEXT |
|
||||
PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShadingHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI |
|
||||
PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShaderHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI |
|
||||
PipelineStageFlagBits2::eAccelerationStructureCopyKHR | PipelineStageFlagBits2::eMicromapBuildEXT | PipelineStageFlagBits2::eClusterCullingShaderHUAWEI |
|
||||
PipelineStageFlagBits2::eOpticalFlowNV;
|
||||
};
|
||||
|
@ -3165,21 +3165,21 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sint:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sfloat:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64B64Uint:
|
||||
@ -5393,7 +5393,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc4SnormBlock:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SRGB";
|
||||
case 0: return "SNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc5UnormBlock:
|
||||
@ -5406,8 +5406,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc5SnormBlock:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 0: return "SNORM";
|
||||
case 1: return "SNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc6HUfloatBlock:
|
||||
|
@ -1590,8 +1590,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
result += "TaskShaderEXT | ";
|
||||
if ( value & PipelineStageFlagBits2::eMeshShaderEXT )
|
||||
result += "MeshShaderEXT | ";
|
||||
if ( value & PipelineStageFlagBits2::eSubpassShadingHUAWEI )
|
||||
result += "SubpassShadingHUAWEI | ";
|
||||
if ( value & PipelineStageFlagBits2::eSubpassShaderHUAWEI )
|
||||
result += "SubpassShaderHUAWEI | ";
|
||||
if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI )
|
||||
result += "InvocationMaskHUAWEI | ";
|
||||
if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR )
|
||||
@ -6278,7 +6278,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case PipelineStageFlagBits2::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
|
||||
case PipelineStageFlagBits2::eTaskShaderEXT: return "TaskShaderEXT";
|
||||
case PipelineStageFlagBits2::eMeshShaderEXT: return "MeshShaderEXT";
|
||||
case PipelineStageFlagBits2::eSubpassShadingHUAWEI: return "SubpassShadingHUAWEI";
|
||||
case PipelineStageFlagBits2::eSubpassShaderHUAWEI: return "SubpassShaderHUAWEI";
|
||||
case PipelineStageFlagBits2::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI";
|
||||
case PipelineStageFlagBits2::eAccelerationStructureCopyKHR: return "AccelerationStructureCopyKHR";
|
||||
case PipelineStageFlagBits2::eMicromapBuildEXT: return "MicromapBuildEXT";
|
||||
|
1467
vulkan/vulkansc.cppm
Normal file
1467
vulkan/vulkansc.cppm
Normal file
File diff suppressed because it is too large
Load Diff
@ -3538,7 +3538,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
|
||||
# else
|
||||
static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
|
||||
inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
|
||||
{
|
||||
static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
|
||||
return dls;
|
||||
@ -4092,9 +4092,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
};
|
||||
|
||||
namespace
|
||||
namespace detail
|
||||
{
|
||||
[[noreturn]] void throwResultException( Result result, char const * message )
|
||||
[[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
|
||||
{
|
||||
switch ( result )
|
||||
{
|
||||
@ -4126,7 +4126,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
default: throw SystemError( make_error_code( result ), message );
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
} // namespace detail
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
@ -4178,7 +4178,15 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
}
|
||||
|
||||
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
|
||||
VULKAN_HPP_DEPRECATED(
|
||||
"asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
|
||||
|
||||
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &
|
||||
{
|
||||
return std::make_tuple( result, std::move( value ) );
|
||||
}
|
||||
|
||||
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &&
|
||||
{
|
||||
return std::make_tuple( result, std::move( value ) );
|
||||
}
|
||||
@ -4200,7 +4208,15 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
}
|
||||
|
||||
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
|
||||
VULKAN_HPP_DEPRECATED(
|
||||
"asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
|
||||
|
||||
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &
|
||||
{
|
||||
return std::make_tuple( result, std::move( value ) );
|
||||
}
|
||||
|
||||
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &&
|
||||
{
|
||||
return std::make_tuple( result, std::move( value ) );
|
||||
}
|
||||
@ -4270,7 +4286,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#else
|
||||
if ( result != Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, message );
|
||||
detail::throwResultException( result, message );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@ -4285,10 +4301,106 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
#else
|
||||
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
|
||||
{
|
||||
throwResultException( result, message );
|
||||
detail::throwResultException( result, message );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
//=========================================
|
||||
//=== CONSTEXPR CONSTANTs AND FUNCTIONs ===
|
||||
//=========================================
|
||||
VULKAN_HPP_CONSTEXPR uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t False = VK_FALSE;
|
||||
VULKAN_HPP_CONSTEXPR float LodClampNone = VK_LOD_CLAMP_NONE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t LuidSize = VK_LUID_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxGlobalPrioritySizeKhr = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t MaxShaderModuleIdentifierSizeExt = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyForeignExt = VK_QUEUE_FAMILY_FOREIGN_EXT;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t Remaining3DSlicesExt = VK_REMAINING_3D_SLICES_EXT;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t ShaderUnusedKhr = VK_SHADER_UNUSED_KHR;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t True = VK_TRUE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t UuidSize = VK_UUID_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint64_t WholeSize = VK_WHOLE_SIZE;
|
||||
VULKAN_HPP_CONSTEXPR uint32_t HeaderVersion = VK_HEADER_VERSION;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version )
|
||||
{
|
||||
return ( ( (uint32_t)( version ) >> 22U ) & 0x7FU );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version )
|
||||
{
|
||||
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
|
||||
{
|
||||
return ( (uint32_t)(version)&0xFFFU );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version )
|
||||
{
|
||||
return ( (uint32_t)( version ) >> 29U );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch )
|
||||
{
|
||||
return ( ( ( (uint32_t)( variant ) ) << 29U ) | ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_MAKE_API_VERSION should be used instead." )
|
||||
VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch )
|
||||
{
|
||||
return ( ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MAJOR should be used instead." )
|
||||
VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version )
|
||||
{
|
||||
return ( (uint32_t)( version ) >> 22U );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MINOR should be used instead." )
|
||||
VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version )
|
||||
{
|
||||
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
|
||||
}
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
||||
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_PATCH should be used instead." )
|
||||
VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
|
||||
{
|
||||
return ( (uint32_t)(version)&0xFFFU );
|
||||
}
|
||||
|
||||
VULKAN_HPP_CONSTEXPR auto ApiVersion = makeApiVersion( 0, 1, 0, 0 );
|
||||
VULKAN_HPP_CONSTEXPR auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 );
|
||||
VULKAN_HPP_CONSTEXPR auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 );
|
||||
VULKAN_HPP_CONSTEXPR auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 );
|
||||
VULKAN_HPP_CONSTEXPR auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 );
|
||||
VULKAN_HPP_CONSTEXPR auto HeaderVersionComplete = makeApiVersion( VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION );
|
||||
|
||||
} // namespace VULKAN_HPP_NAMESPACE
|
||||
|
||||
// clang-format off
|
||||
|
@ -3123,21 +3123,21 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sint:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sfloat:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "R";
|
||||
case 1: return "B";
|
||||
case 1: return "G";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eR64G64B64Uint:
|
||||
@ -5272,7 +5272,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc4SnormBlock:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SRGB";
|
||||
case 0: return "SNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc5UnormBlock:
|
||||
@ -5285,8 +5285,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc5SnormBlock:
|
||||
switch ( component )
|
||||
{
|
||||
case 0: return "SRGB";
|
||||
case 1: return "SRGB";
|
||||
case 0: return "SNORM";
|
||||
case 1: return "SNORM";
|
||||
default: VULKAN_HPP_ASSERT( false ); return "";
|
||||
}
|
||||
case VULKAN_HPP_NAMESPACE::Format::eBc6HUfloatBlock:
|
||||
|
@ -1201,7 +1201,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkInstance *>( &m_instance ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateInstance" );
|
||||
detail::throwResultException( result, "vkCreateInstance" );
|
||||
}
|
||||
m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr,
|
||||
static_cast<VkInstance>( m_instance ) ) );
|
||||
@ -1239,10 +1239,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher.reset( rhs.m_dispatcher.release() );
|
||||
std::swap( m_instance, rhs.m_instance );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -1364,8 +1363,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_physicalDevice, rhs.m_physicalDevice );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -1604,7 +1603,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
else
|
||||
{
|
||||
throwResultException( result, "vkEnumeratePhysicalDevices" );
|
||||
detail::throwResultException( result, "vkEnumeratePhysicalDevices" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -1639,7 +1638,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkDevice *>( &m_device ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateDevice" );
|
||||
detail::throwResultException( result, "vkCreateDevice" );
|
||||
}
|
||||
m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr,
|
||||
static_cast<VkDevice>( m_device ) ) );
|
||||
@ -1677,10 +1676,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher.reset( rhs.m_dispatcher.release() );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -2066,7 +2064,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkBuffer *>( &m_buffer ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateBuffer" );
|
||||
detail::throwResultException( result, "vkCreateBuffer" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -2104,11 +2102,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_buffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_buffer, rhs.m_buffer );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -2195,7 +2192,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkBufferView *>( &m_bufferView ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateBufferView" );
|
||||
detail::throwResultException( result, "vkCreateBufferView" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -2233,11 +2230,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_bufferView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_bufferView, rhs.m_bufferView );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -2318,7 +2314,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkCommandPool *>( &m_commandPool ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateCommandPool" );
|
||||
detail::throwResultException( result, "vkCreateCommandPool" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -2356,11 +2352,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_commandPool, rhs.m_commandPool );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -2465,11 +2460,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} );
|
||||
m_commandBuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_commandPool, rhs.m_commandPool );
|
||||
std::swap( m_commandBuffer, rhs.m_commandBuffer );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -2948,7 +2942,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
else
|
||||
{
|
||||
throwResultException( result, "vkAllocateCommandBuffers" );
|
||||
detail::throwResultException( result, "vkAllocateCommandBuffers" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -2985,7 +2979,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_messenger ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateDebugUtilsMessengerEXT" );
|
||||
detail::throwResultException( result, "vkCreateDebugUtilsMessengerEXT" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3023,11 +3017,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
|
||||
m_messenger = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_instance, rhs.m_instance );
|
||||
std::swap( m_messenger, rhs.m_messenger );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -3109,7 +3102,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkDescriptorPool *>( &m_descriptorPool ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateDescriptorPool" );
|
||||
detail::throwResultException( result, "vkCreateDescriptorPool" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3147,11 +3140,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_descriptorPool, rhs.m_descriptorPool );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -3252,11 +3244,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
|
||||
m_descriptorSet = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_descriptorPool, rhs.m_descriptorPool );
|
||||
std::swap( m_descriptorSet, rhs.m_descriptorSet );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -3335,7 +3326,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
else
|
||||
{
|
||||
throwResultException( result, "vkAllocateDescriptorSets" );
|
||||
detail::throwResultException( result, "vkAllocateDescriptorSets" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3372,7 +3363,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkDescriptorSetLayout *>( &m_descriptorSetLayout ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateDescriptorSetLayout" );
|
||||
detail::throwResultException( result, "vkCreateDescriptorSetLayout" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3410,11 +3401,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -3496,7 +3486,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkDeviceMemory *>( &m_memory ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkAllocateMemory" );
|
||||
detail::throwResultException( result, "vkAllocateMemory" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3534,11 +3524,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_memory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_memory, rhs.m_memory );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -3643,10 +3632,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
|
||||
m_display = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_physicalDevice, rhs.m_physicalDevice );
|
||||
std::swap( m_display, rhs.m_display );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -3741,7 +3729,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
else
|
||||
{
|
||||
throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" );
|
||||
detail::throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3777,7 +3765,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkDisplayModeKHR *>( &m_displayModeKHR ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateDisplayModeKHR" );
|
||||
detail::throwResultException( result, "vkCreateDisplayModeKHR" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3815,9 +3803,9 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
|
||||
m_displayModeKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_physicalDevice, rhs.m_physicalDevice );
|
||||
std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -3888,7 +3876,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkEvent *>( &m_event ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateEvent" );
|
||||
detail::throwResultException( result, "vkCreateEvent" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -3926,11 +3914,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_event = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_event, rhs.m_event );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -4019,7 +4006,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkFence *>( &m_fence ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateFence" );
|
||||
detail::throwResultException( result, "vkCreateFence" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4037,7 +4024,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkFence *>( &m_fence ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkRegisterDeviceEventEXT" );
|
||||
detail::throwResultException( result, "vkRegisterDeviceEventEXT" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4057,7 +4044,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkFence *>( &m_fence ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkRegisterDisplayEventEXT" );
|
||||
detail::throwResultException( result, "vkRegisterDisplayEventEXT" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4095,11 +4082,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_fence = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_fence, rhs.m_fence );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -4184,7 +4170,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkFramebuffer *>( &m_framebuffer ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateFramebuffer" );
|
||||
detail::throwResultException( result, "vkCreateFramebuffer" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4222,11 +4208,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_framebuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_framebuffer, rhs.m_framebuffer );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -4307,7 +4292,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkImage *>( &m_image ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateImage" );
|
||||
detail::throwResultException( result, "vkCreateImage" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4345,11 +4330,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_image = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_image, rhs.m_image );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -4443,7 +4427,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkImageView *>( &m_imageView ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateImageView" );
|
||||
detail::throwResultException( result, "vkCreateImageView" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4481,11 +4465,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_imageView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_imageView, rhs.m_imageView );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -4566,7 +4549,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkPipelineCache *>( &m_pipelineCache ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreatePipelineCache" );
|
||||
detail::throwResultException( result, "vkCreatePipelineCache" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4604,11 +4587,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_pipelineCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_pipelineCache, rhs.m_pipelineCache );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -4712,7 +4694,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
|
||||
( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
|
||||
{
|
||||
throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" );
|
||||
detail::throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4734,7 +4716,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
|
||||
( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
|
||||
{
|
||||
throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" );
|
||||
detail::throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4775,12 +4757,11 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_pipeline = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_pipeline, rhs.m_pipeline );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -4873,7 +4854,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
else
|
||||
{
|
||||
throwResultException( result, "vkCreateComputePipelines" );
|
||||
detail::throwResultException( result, "vkCreateComputePipelines" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4901,7 +4882,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
else
|
||||
{
|
||||
throwResultException( result, "vkCreateGraphicsPipelines" );
|
||||
detail::throwResultException( result, "vkCreateGraphicsPipelines" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4938,7 +4919,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkPipelineLayout *>( &m_pipelineLayout ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreatePipelineLayout" );
|
||||
detail::throwResultException( result, "vkCreatePipelineLayout" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -4976,11 +4957,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_pipelineLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5062,7 +5042,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkPrivateDataSlot *>( &m_privateDataSlot ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreatePrivateDataSlot" );
|
||||
detail::throwResultException( result, "vkCreatePrivateDataSlot" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -5100,11 +5080,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_privateDataSlot = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5186,7 +5165,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkQueryPool *>( &m_queryPool ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateQueryPool" );
|
||||
detail::throwResultException( result, "vkCreateQueryPool" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -5224,11 +5203,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_queryPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_queryPool, rhs.m_queryPool );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5361,8 +5339,8 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
m_queue = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_queue, rhs.m_queue );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5456,7 +5434,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateRenderPass" );
|
||||
detail::throwResultException( result, "vkCreateRenderPass" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -5474,7 +5452,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateRenderPass2" );
|
||||
detail::throwResultException( result, "vkCreateRenderPass2" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -5512,11 +5490,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_renderPass = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_renderPass, rhs.m_renderPass );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5601,7 +5578,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkSampler *>( &m_sampler ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateSampler" );
|
||||
detail::throwResultException( result, "vkCreateSampler" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -5639,11 +5616,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_sampler = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_sampler, rhs.m_sampler );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5724,7 +5700,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkSamplerYcbcrConversion *>( &m_ycbcrConversion ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateSamplerYcbcrConversion" );
|
||||
detail::throwResultException( result, "vkCreateSamplerYcbcrConversion" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -5762,11 +5738,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_ycbcrConversion = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5848,7 +5823,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkSemaphore *>( &m_semaphore ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateSemaphore" );
|
||||
detail::throwResultException( result, "vkCreateSemaphore" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -5886,11 +5861,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_semaphore = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_semaphore, rhs.m_semaphore );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -5976,7 +5950,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkSemaphoreSciSyncPoolNV *>( &m_semaphorePool ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateSemaphoreSciSyncPoolNV" );
|
||||
detail::throwResultException( result, "vkCreateSemaphoreSciSyncPoolNV" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -6014,11 +5988,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_semaphorePool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphorePool, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_semaphorePool, rhs.m_semaphorePool );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -6101,7 +6074,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkShaderModule *>( &m_shaderModule ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateShaderModule" );
|
||||
detail::throwResultException( result, "vkCreateShaderModule" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -6139,11 +6112,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_shaderModule = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_shaderModule, rhs.m_shaderModule );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -6224,7 +6196,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" );
|
||||
detail::throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -6242,7 +6214,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateHeadlessSurfaceEXT" );
|
||||
detail::throwResultException( result, "vkCreateHeadlessSurfaceEXT" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -6280,11 +6252,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
|
||||
m_surface = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_instance, rhs.m_instance );
|
||||
std::swap( m_surface, rhs.m_surface );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -6365,7 +6336,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
reinterpret_cast<VkSwapchainKHR *>( &m_swapchain ) ) );
|
||||
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
|
||||
{
|
||||
throwResultException( result, "vkCreateSwapchainKHR" );
|
||||
detail::throwResultException( result, "vkCreateSwapchainKHR" );
|
||||
}
|
||||
}
|
||||
|
||||
@ -6403,11 +6374,10 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
{
|
||||
if ( this != &rhs )
|
||||
{
|
||||
clear();
|
||||
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
|
||||
m_swapchain = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} );
|
||||
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
|
||||
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
|
||||
std::swap( m_device, rhs.m_device );
|
||||
std::swap( m_swapchain, rhs.m_swapchain );
|
||||
std::swap( m_allocator, rhs.m_allocator );
|
||||
std::swap( m_dispatcher, rhs.m_dispatcher );
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@ -6506,7 +6476,7 @@ namespace VULKAN_HPP_NAMESPACE
|
||||
}
|
||||
else
|
||||
{
|
||||
throwResultException( result, "vkCreateSharedSwapchainsKHR" );
|
||||
detail::throwResultException( result, "vkCreateSharedSwapchainsKHR" );
|
||||
}
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user