blob: 755fa45e189af8b9a481e41a820a6c5178408ee1 [file] [log] [blame]
// Copyright 2015-2022 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
// This header is generated from the Khronos Vulkan XML API Registry.
#ifndef VULKAN_TO_STRING_HPP
#define VULKAN_TO_STRING_HPP
#include <vulkan/vulkan_enums.hpp>
#if ( ( 20 <= VULKAN_HPP_CPP_VERSION ) && __has_include( <format> ) )
# include <format> // std::format
#else
# include <sstream> // std::stringstream
#endif
namespace VULKAN_HPP_NAMESPACE
{
//==========================
//=== BITMASKs to_string ===
//==========================
//=== VK_VERSION_1_0 ===
VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & FormatFeatureFlagBits::eSampledImage )
result += "SampledImage | ";
if ( value & FormatFeatureFlagBits::eStorageImage )
result += "StorageImage | ";
if ( value & FormatFeatureFlagBits::eStorageImageAtomic )
result += "StorageImageAtomic | ";
if ( value & FormatFeatureFlagBits::eUniformTexelBuffer )
result += "UniformTexelBuffer | ";
if ( value & FormatFeatureFlagBits::eStorageTexelBuffer )
result += "StorageTexelBuffer | ";
if ( value & FormatFeatureFlagBits::eStorageTexelBufferAtomic )
result += "StorageTexelBufferAtomic | ";
if ( value & FormatFeatureFlagBits::eVertexBuffer )
result += "VertexBuffer | ";
if ( value & FormatFeatureFlagBits::eColorAttachment )
result += "ColorAttachment | ";
if ( value & FormatFeatureFlagBits::eColorAttachmentBlend )
result += "ColorAttachmentBlend | ";
if ( value & FormatFeatureFlagBits::eDepthStencilAttachment )
result += "DepthStencilAttachment | ";
if ( value & FormatFeatureFlagBits::eBlitSrc )
result += "BlitSrc | ";
if ( value & FormatFeatureFlagBits::eBlitDst )
result += "BlitDst | ";
if ( value & FormatFeatureFlagBits::eSampledImageFilterLinear )
result += "SampledImageFilterLinear | ";
if ( value & FormatFeatureFlagBits::eTransferSrc )
result += "TransferSrc | ";
if ( value & FormatFeatureFlagBits::eTransferDst )
result += "TransferDst | ";
if ( value & FormatFeatureFlagBits::eMidpointChromaSamples )
result += "MidpointChromaSamples | ";
if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter )
result += "SampledImageYcbcrConversionLinearFilter | ";
if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter )
result += "SampledImageYcbcrConversionSeparateReconstructionFilter | ";
if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit )
result += "SampledImageYcbcrConversionChromaReconstructionExplicit | ";
if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable )
result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | ";
if ( value & FormatFeatureFlagBits::eDisjoint )
result += "Disjoint | ";
if ( value & FormatFeatureFlagBits::eCositedChromaSamples )
result += "CositedChromaSamples | ";
if ( value & FormatFeatureFlagBits::eSampledImageFilterMinmax )
result += "SampledImageFilterMinmax | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & FormatFeatureFlagBits::eVideoDecodeOutputKHR )
result += "VideoDecodeOutputKHR | ";
if ( value & FormatFeatureFlagBits::eVideoDecodeDpbKHR )
result += "VideoDecodeDpbKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR )
result += "AccelerationStructureVertexBufferKHR | ";
if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicEXT )
result += "SampledImageFilterCubicEXT | ";
if ( value & FormatFeatureFlagBits::eFragmentDensityMapEXT )
result += "FragmentDensityMapEXT | ";
if ( value & FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR )
result += "FragmentShadingRateAttachmentKHR | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & FormatFeatureFlagBits::eVideoEncodeInputKHR )
result += "VideoEncodeInputKHR | ";
if ( value & FormatFeatureFlagBits::eVideoEncodeDpbKHR )
result += "VideoEncodeDpbKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ImageCreateFlagBits::eSparseBinding )
result += "SparseBinding | ";
if ( value & ImageCreateFlagBits::eSparseResidency )
result += "SparseResidency | ";
if ( value & ImageCreateFlagBits::eSparseAliased )
result += "SparseAliased | ";
if ( value & ImageCreateFlagBits::eMutableFormat )
result += "MutableFormat | ";
if ( value & ImageCreateFlagBits::eCubeCompatible )
result += "CubeCompatible | ";
if ( value & ImageCreateFlagBits::eAlias )
result += "Alias | ";
if ( value & ImageCreateFlagBits::eSplitInstanceBindRegions )
result += "SplitInstanceBindRegions | ";
if ( value & ImageCreateFlagBits::e2DArrayCompatible )
result += "2DArrayCompatible | ";
if ( value & ImageCreateFlagBits::eBlockTexelViewCompatible )
result += "BlockTexelViewCompatible | ";
if ( value & ImageCreateFlagBits::eExtendedUsage )
result += "ExtendedUsage | ";
if ( value & ImageCreateFlagBits::eProtected )
result += "Protected | ";
if ( value & ImageCreateFlagBits::eDisjoint )
result += "Disjoint | ";
if ( value & ImageCreateFlagBits::eCornerSampledNV )
result += "CornerSampledNV | ";
if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT )
result += "SampleLocationsCompatibleDepthEXT | ";
if ( value & ImageCreateFlagBits::eSubsampledEXT )
result += "SubsampledEXT | ";
if ( value & ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT )
result += "MultisampledRenderToSingleSampledEXT | ";
if ( value & ImageCreateFlagBits::e2DViewCompatibleEXT )
result += "2DViewCompatibleEXT | ";
if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM )
result += "FragmentDensityMapOffsetQCOM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ImageUsageFlagBits::eTransferSrc )
result += "TransferSrc | ";
if ( value & ImageUsageFlagBits::eTransferDst )
result += "TransferDst | ";
if ( value & ImageUsageFlagBits::eSampled )
result += "Sampled | ";
if ( value & ImageUsageFlagBits::eStorage )
result += "Storage | ";
if ( value & ImageUsageFlagBits::eColorAttachment )
result += "ColorAttachment | ";
if ( value & ImageUsageFlagBits::eDepthStencilAttachment )
result += "DepthStencilAttachment | ";
if ( value & ImageUsageFlagBits::eTransientAttachment )
result += "TransientAttachment | ";
if ( value & ImageUsageFlagBits::eInputAttachment )
result += "InputAttachment | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & ImageUsageFlagBits::eVideoDecodeDstKHR )
result += "VideoDecodeDstKHR | ";
if ( value & ImageUsageFlagBits::eVideoDecodeSrcKHR )
result += "VideoDecodeSrcKHR | ";
if ( value & ImageUsageFlagBits::eVideoDecodeDpbKHR )
result += "VideoDecodeDpbKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT )
result += "FragmentDensityMapEXT | ";
if ( value & ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR )
result += "FragmentShadingRateAttachmentKHR | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & ImageUsageFlagBits::eVideoEncodeDstKHR )
result += "VideoEncodeDstKHR | ";
if ( value & ImageUsageFlagBits::eVideoEncodeSrcKHR )
result += "VideoEncodeSrcKHR | ";
if ( value & ImageUsageFlagBits::eVideoEncodeDpbKHR )
result += "VideoEncodeDpbKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & ImageUsageFlagBits::eAttachmentFeedbackLoopEXT )
result += "AttachmentFeedbackLoopEXT | ";
if ( value & ImageUsageFlagBits::eInvocationMaskHUAWEI )
result += "InvocationMaskHUAWEI | ";
if ( value & ImageUsageFlagBits::eSampleWeightQCOM )
result += "SampleWeightQCOM | ";
if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM )
result += "SampleBlockMatchQCOM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & InstanceCreateFlagBits::eEnumeratePortabilityKHR )
result += "EnumeratePortabilityKHR | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & MemoryHeapFlagBits::eDeviceLocal )
result += "DeviceLocal | ";
if ( value & MemoryHeapFlagBits::eMultiInstance )
result += "MultiInstance | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & MemoryPropertyFlagBits::eDeviceLocal )
result += "DeviceLocal | ";
if ( value & MemoryPropertyFlagBits::eHostVisible )
result += "HostVisible | ";
if ( value & MemoryPropertyFlagBits::eHostCoherent )
result += "HostCoherent | ";
if ( value & MemoryPropertyFlagBits::eHostCached )
result += "HostCached | ";
if ( value & MemoryPropertyFlagBits::eLazilyAllocated )
result += "LazilyAllocated | ";
if ( value & MemoryPropertyFlagBits::eProtected )
result += "Protected | ";
if ( value & MemoryPropertyFlagBits::eDeviceCoherentAMD )
result += "DeviceCoherentAMD | ";
if ( value & MemoryPropertyFlagBits::eDeviceUncachedAMD )
result += "DeviceUncachedAMD | ";
if ( value & MemoryPropertyFlagBits::eRdmaCapableNV )
result += "RdmaCapableNV | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( QueueFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & QueueFlagBits::eGraphics )
result += "Graphics | ";
if ( value & QueueFlagBits::eCompute )
result += "Compute | ";
if ( value & QueueFlagBits::eTransfer )
result += "Transfer | ";
if ( value & QueueFlagBits::eSparseBinding )
result += "SparseBinding | ";
if ( value & QueueFlagBits::eProtected )
result += "Protected | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & QueueFlagBits::eVideoDecodeKHR )
result += "VideoDecodeKHR | ";
if ( value & QueueFlagBits::eVideoEncodeKHR )
result += "VideoEncodeKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SampleCountFlagBits::e1 )
result += "1 | ";
if ( value & SampleCountFlagBits::e2 )
result += "2 | ";
if ( value & SampleCountFlagBits::e4 )
result += "4 | ";
if ( value & SampleCountFlagBits::e8 )
result += "8 | ";
if ( value & SampleCountFlagBits::e16 )
result += "16 | ";
if ( value & SampleCountFlagBits::e32 )
result += "32 | ";
if ( value & SampleCountFlagBits::e64 )
result += "64 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DeviceQueueCreateFlagBits::eProtected )
result += "Protected | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineStageFlagBits::eTopOfPipe )
result += "TopOfPipe | ";
if ( value & PipelineStageFlagBits::eDrawIndirect )
result += "DrawIndirect | ";
if ( value & PipelineStageFlagBits::eVertexInput )
result += "VertexInput | ";
if ( value & PipelineStageFlagBits::eVertexShader )
result += "VertexShader | ";
if ( value & PipelineStageFlagBits::eTessellationControlShader )
result += "TessellationControlShader | ";
if ( value & PipelineStageFlagBits::eTessellationEvaluationShader )
result += "TessellationEvaluationShader | ";
if ( value & PipelineStageFlagBits::eGeometryShader )
result += "GeometryShader | ";
if ( value & PipelineStageFlagBits::eFragmentShader )
result += "FragmentShader | ";
if ( value & PipelineStageFlagBits::eEarlyFragmentTests )
result += "EarlyFragmentTests | ";
if ( value & PipelineStageFlagBits::eLateFragmentTests )
result += "LateFragmentTests | ";
if ( value & PipelineStageFlagBits::eColorAttachmentOutput )
result += "ColorAttachmentOutput | ";
if ( value & PipelineStageFlagBits::eComputeShader )
result += "ComputeShader | ";
if ( value & PipelineStageFlagBits::eTransfer )
result += "Transfer | ";
if ( value & PipelineStageFlagBits::eBottomOfPipe )
result += "BottomOfPipe | ";
if ( value & PipelineStageFlagBits::eHost )
result += "Host | ";
if ( value & PipelineStageFlagBits::eAllGraphics )
result += "AllGraphics | ";
if ( value & PipelineStageFlagBits::eAllCommands )
result += "AllCommands | ";
if ( value & PipelineStageFlagBits::eTransformFeedbackEXT )
result += "TransformFeedbackEXT | ";
if ( value & PipelineStageFlagBits::eConditionalRenderingEXT )
result += "ConditionalRenderingEXT | ";
if ( value & PipelineStageFlagBits::eAccelerationStructureBuildKHR )
result += "AccelerationStructureBuildKHR | ";
if ( value & PipelineStageFlagBits::eRayTracingShaderKHR )
result += "RayTracingShaderKHR | ";
if ( value & PipelineStageFlagBits::eTaskShaderNV )
result += "TaskShaderNV | ";
if ( value & PipelineStageFlagBits::eMeshShaderNV )
result += "MeshShaderNV | ";
if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT )
result += "FragmentDensityProcessEXT | ";
if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR )
result += "FragmentShadingRateAttachmentKHR | ";
if ( value & PipelineStageFlagBits::eCommandPreprocessNV )
result += "CommandPreprocessNV | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ImageAspectFlagBits::eColor )
result += "Color | ";
if ( value & ImageAspectFlagBits::eDepth )
result += "Depth | ";
if ( value & ImageAspectFlagBits::eStencil )
result += "Stencil | ";
if ( value & ImageAspectFlagBits::eMetadata )
result += "Metadata | ";
if ( value & ImageAspectFlagBits::ePlane0 )
result += "Plane0 | ";
if ( value & ImageAspectFlagBits::ePlane1 )
result += "Plane1 | ";
if ( value & ImageAspectFlagBits::ePlane2 )
result += "Plane2 | ";
if ( value & ImageAspectFlagBits::eMemoryPlane0EXT )
result += "MemoryPlane0EXT | ";
if ( value & ImageAspectFlagBits::eMemoryPlane1EXT )
result += "MemoryPlane1EXT | ";
if ( value & ImageAspectFlagBits::eMemoryPlane2EXT )
result += "MemoryPlane2EXT | ";
if ( value & ImageAspectFlagBits::eMemoryPlane3EXT )
result += "MemoryPlane3EXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SparseImageFormatFlagBits::eSingleMiptail )
result += "SingleMiptail | ";
if ( value & SparseImageFormatFlagBits::eAlignedMipSize )
result += "AlignedMipSize | ";
if ( value & SparseImageFormatFlagBits::eNonstandardBlockSize )
result += "NonstandardBlockSize | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SparseMemoryBindFlagBits::eMetadata )
result += "Metadata | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & FenceCreateFlagBits::eSignaled )
result += "Signaled | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( EventCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & EventCreateFlagBits::eDeviceOnly )
result += "DeviceOnly | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices )
result += "InputAssemblyVertices | ";
if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives )
result += "InputAssemblyPrimitives | ";
if ( value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations )
result += "VertexShaderInvocations | ";
if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations )
result += "GeometryShaderInvocations | ";
if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives )
result += "GeometryShaderPrimitives | ";
if ( value & QueryPipelineStatisticFlagBits::eClippingInvocations )
result += "ClippingInvocations | ";
if ( value & QueryPipelineStatisticFlagBits::eClippingPrimitives )
result += "ClippingPrimitives | ";
if ( value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations )
result += "FragmentShaderInvocations | ";
if ( value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches )
result += "TessellationControlShaderPatches | ";
if ( value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations )
result += "TessellationEvaluationShaderInvocations | ";
if ( value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations )
result += "ComputeShaderInvocations | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & QueryResultFlagBits::e64 )
result += "64 | ";
if ( value & QueryResultFlagBits::eWait )
result += "Wait | ";
if ( value & QueryResultFlagBits::eWithAvailability )
result += "WithAvailability | ";
if ( value & QueryResultFlagBits::ePartial )
result += "Partial | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & QueryResultFlagBits::eWithStatusKHR )
result += "WithStatusKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & BufferCreateFlagBits::eSparseBinding )
result += "SparseBinding | ";
if ( value & BufferCreateFlagBits::eSparseResidency )
result += "SparseResidency | ";
if ( value & BufferCreateFlagBits::eSparseAliased )
result += "SparseAliased | ";
if ( value & BufferCreateFlagBits::eProtected )
result += "Protected | ";
if ( value & BufferCreateFlagBits::eDeviceAddressCaptureReplay )
result += "DeviceAddressCaptureReplay | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & BufferUsageFlagBits::eTransferSrc )
result += "TransferSrc | ";
if ( value & BufferUsageFlagBits::eTransferDst )
result += "TransferDst | ";
if ( value & BufferUsageFlagBits::eUniformTexelBuffer )
result += "UniformTexelBuffer | ";
if ( value & BufferUsageFlagBits::eStorageTexelBuffer )
result += "StorageTexelBuffer | ";
if ( value & BufferUsageFlagBits::eUniformBuffer )
result += "UniformBuffer | ";
if ( value & BufferUsageFlagBits::eStorageBuffer )
result += "StorageBuffer | ";
if ( value & BufferUsageFlagBits::eIndexBuffer )
result += "IndexBuffer | ";
if ( value & BufferUsageFlagBits::eVertexBuffer )
result += "VertexBuffer | ";
if ( value & BufferUsageFlagBits::eIndirectBuffer )
result += "IndirectBuffer | ";
if ( value & BufferUsageFlagBits::eShaderDeviceAddress )
result += "ShaderDeviceAddress | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & BufferUsageFlagBits::eVideoDecodeSrcKHR )
result += "VideoDecodeSrcKHR | ";
if ( value & BufferUsageFlagBits::eVideoDecodeDstKHR )
result += "VideoDecodeDstKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT )
result += "TransformFeedbackBufferEXT | ";
if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT )
result += "TransformFeedbackCounterBufferEXT | ";
if ( value & BufferUsageFlagBits::eConditionalRenderingEXT )
result += "ConditionalRenderingEXT | ";
if ( value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR )
result += "AccelerationStructureBuildInputReadOnlyKHR | ";
if ( value & BufferUsageFlagBits::eAccelerationStructureStorageKHR )
result += "AccelerationStructureStorageKHR | ";
if ( value & BufferUsageFlagBits::eShaderBindingTableKHR )
result += "ShaderBindingTableKHR | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & BufferUsageFlagBits::eVideoEncodeDstKHR )
result += "VideoEncodeDstKHR | ";
if ( value & BufferUsageFlagBits::eVideoEncodeSrcKHR )
result += "VideoEncodeSrcKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT )
result += "FragmentDensityMapDynamicEXT | ";
if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT )
result += "FragmentDensityMapDeferredEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ShaderModuleCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineCacheCreateFlagBits::eExternallySynchronized )
result += "ExternallySynchronized | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ColorComponentFlagBits::eR )
result += "R | ";
if ( value & ColorComponentFlagBits::eG )
result += "G | ";
if ( value & ColorComponentFlagBits::eB )
result += "B | ";
if ( value & ColorComponentFlagBits::eA )
result += "A | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( CullModeFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & CullModeFlagBits::eFront )
result += "Front | ";
if ( value & CullModeFlagBits::eBack )
result += "Back | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessARM )
result += "RasterizationOrderAttachmentAccessARM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineCreateFlagBits::eDisableOptimization )
result += "DisableOptimization | ";
if ( value & PipelineCreateFlagBits::eAllowDerivatives )
result += "AllowDerivatives | ";
if ( value & PipelineCreateFlagBits::eDerivative )
result += "Derivative | ";
if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex )
result += "ViewIndexFromDeviceIndex | ";
if ( value & PipelineCreateFlagBits::eDispatchBase )
result += "DispatchBase | ";
if ( value & PipelineCreateFlagBits::eFailOnPipelineCompileRequired )
result += "FailOnPipelineCompileRequired | ";
if ( value & PipelineCreateFlagBits::eEarlyReturnOnFailure )
result += "EarlyReturnOnFailure | ";
if ( value & PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR )
result += "RenderingFragmentShadingRateAttachmentKHR | ";
if ( value & PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT )
result += "RenderingFragmentDensityMapAttachmentEXT | ";
if ( value & PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR )
result += "RayTracingNoNullAnyHitShadersKHR | ";
if ( value & PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR )
result += "RayTracingNoNullClosestHitShadersKHR | ";
if ( value & PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR )
result += "RayTracingNoNullMissShadersKHR | ";
if ( value & PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR )
result += "RayTracingNoNullIntersectionShadersKHR | ";
if ( value & PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR )
result += "RayTracingSkipTrianglesKHR | ";
if ( value & PipelineCreateFlagBits::eRayTracingSkipAabbsKHR )
result += "RayTracingSkipAabbsKHR | ";
if ( value & PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR )
result += "RayTracingShaderGroupHandleCaptureReplayKHR | ";
if ( value & PipelineCreateFlagBits::eDeferCompileNV )
result += "DeferCompileNV | ";
if ( value & PipelineCreateFlagBits::eCaptureStatisticsKHR )
result += "CaptureStatisticsKHR | ";
if ( value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR )
result += "CaptureInternalRepresentationsKHR | ";
if ( value & PipelineCreateFlagBits::eIndirectBindableNV )
result += "IndirectBindableNV | ";
if ( value & PipelineCreateFlagBits::eLibraryKHR )
result += "LibraryKHR | ";
if ( value & PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT )
result += "RetainLinkTimeOptimizationInfoEXT | ";
if ( value & PipelineCreateFlagBits::eLinkTimeOptimizationEXT )
result += "LinkTimeOptimizationEXT | ";
if ( value & PipelineCreateFlagBits::eRayTracingAllowMotionNV )
result += "RayTracingAllowMotionNV | ";
if ( value & PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT )
result += "ColorAttachmentFeedbackLoopEXT | ";
if ( value & PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT )
result += "DepthStencilAttachmentFeedbackLoopEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessARM )
result += "RasterizationOrderAttachmentDepthAccessARM | ";
if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessARM )
result += "RasterizationOrderAttachmentStencilAccessARM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineLayoutCreateFlagBits::eIndependentSetsEXT )
result += "IndependentSetsEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize )
result += "AllowVaryingSubgroupSize | ";
if ( value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroups )
result += "RequireFullSubgroups | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ShaderStageFlagBits::eVertex )
result += "Vertex | ";
if ( value & ShaderStageFlagBits::eTessellationControl )
result += "TessellationControl | ";
if ( value & ShaderStageFlagBits::eTessellationEvaluation )
result += "TessellationEvaluation | ";
if ( value & ShaderStageFlagBits::eGeometry )
result += "Geometry | ";
if ( value & ShaderStageFlagBits::eFragment )
result += "Fragment | ";
if ( value & ShaderStageFlagBits::eCompute )
result += "Compute | ";
if ( value & ShaderStageFlagBits::eRaygenKHR )
result += "RaygenKHR | ";
if ( value & ShaderStageFlagBits::eAnyHitKHR )
result += "AnyHitKHR | ";
if ( value & ShaderStageFlagBits::eClosestHitKHR )
result += "ClosestHitKHR | ";
if ( value & ShaderStageFlagBits::eMissKHR )
result += "MissKHR | ";
if ( value & ShaderStageFlagBits::eIntersectionKHR )
result += "IntersectionKHR | ";
if ( value & ShaderStageFlagBits::eCallableKHR )
result += "CallableKHR | ";
if ( value & ShaderStageFlagBits::eTaskNV )
result += "TaskNV | ";
if ( value & ShaderStageFlagBits::eMeshNV )
result += "MeshNV | ";
if ( value & ShaderStageFlagBits::eSubpassShadingHUAWEI )
result += "SubpassShadingHUAWEI | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SamplerCreateFlagBits::eSubsampledEXT )
result += "SubsampledEXT | ";
if ( value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT )
result += "SubsampledCoarseReconstructionEXT | ";
if ( value & SamplerCreateFlagBits::eNonSeamlessCubeMapEXT )
result += "NonSeamlessCubeMapEXT | ";
if ( value & SamplerCreateFlagBits::eImageProcessingQCOM )
result += "ImageProcessingQCOM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet )
result += "FreeDescriptorSet | ";
if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind )
result += "UpdateAfterBind | ";
if ( value & DescriptorPoolCreateFlagBits::eHostOnlyVALVE )
result += "HostOnlyVALVE | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool )
result += "UpdateAfterBindPool | ";
if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR )
result += "PushDescriptorKHR | ";
if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolVALVE )
result += "HostOnlyPoolVALVE | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( AccessFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & AccessFlagBits::eIndirectCommandRead )
result += "IndirectCommandRead | ";
if ( value & AccessFlagBits::eIndexRead )
result += "IndexRead | ";
if ( value & AccessFlagBits::eVertexAttributeRead )
result += "VertexAttributeRead | ";
if ( value & AccessFlagBits::eUniformRead )
result += "UniformRead | ";
if ( value & AccessFlagBits::eInputAttachmentRead )
result += "InputAttachmentRead | ";
if ( value & AccessFlagBits::eShaderRead )
result += "ShaderRead | ";
if ( value & AccessFlagBits::eShaderWrite )
result += "ShaderWrite | ";
if ( value & AccessFlagBits::eColorAttachmentRead )
result += "ColorAttachmentRead | ";
if ( value & AccessFlagBits::eColorAttachmentWrite )
result += "ColorAttachmentWrite | ";
if ( value & AccessFlagBits::eDepthStencilAttachmentRead )
result += "DepthStencilAttachmentRead | ";
if ( value & AccessFlagBits::eDepthStencilAttachmentWrite )
result += "DepthStencilAttachmentWrite | ";
if ( value & AccessFlagBits::eTransferRead )
result += "TransferRead | ";
if ( value & AccessFlagBits::eTransferWrite )
result += "TransferWrite | ";
if ( value & AccessFlagBits::eHostRead )
result += "HostRead | ";
if ( value & AccessFlagBits::eHostWrite )
result += "HostWrite | ";
if ( value & AccessFlagBits::eMemoryRead )
result += "MemoryRead | ";
if ( value & AccessFlagBits::eMemoryWrite )
result += "MemoryWrite | ";
if ( value & AccessFlagBits::eTransformFeedbackWriteEXT )
result += "TransformFeedbackWriteEXT | ";
if ( value & AccessFlagBits::eTransformFeedbackCounterReadEXT )
result += "TransformFeedbackCounterReadEXT | ";
if ( value & AccessFlagBits::eTransformFeedbackCounterWriteEXT )
result += "TransformFeedbackCounterWriteEXT | ";
if ( value & AccessFlagBits::eConditionalRenderingReadEXT )
result += "ConditionalRenderingReadEXT | ";
if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT )
result += "ColorAttachmentReadNoncoherentEXT | ";
if ( value & AccessFlagBits::eAccelerationStructureReadKHR )
result += "AccelerationStructureReadKHR | ";
if ( value & AccessFlagBits::eAccelerationStructureWriteKHR )
result += "AccelerationStructureWriteKHR | ";
if ( value & AccessFlagBits::eFragmentDensityMapReadEXT )
result += "FragmentDensityMapReadEXT | ";
if ( value & AccessFlagBits::eFragmentShadingRateAttachmentReadKHR )
result += "FragmentShadingRateAttachmentReadKHR | ";
if ( value & AccessFlagBits::eCommandPreprocessReadNV )
result += "CommandPreprocessReadNV | ";
if ( value & AccessFlagBits::eCommandPreprocessWriteNV )
result += "CommandPreprocessWriteNV | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & AttachmentDescriptionFlagBits::eMayAlias )
result += "MayAlias | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( DependencyFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DependencyFlagBits::eByRegion )
result += "ByRegion | ";
if ( value & DependencyFlagBits::eDeviceGroup )
result += "DeviceGroup | ";
if ( value & DependencyFlagBits::eViewLocal )
result += "ViewLocal | ";
if ( value & DependencyFlagBits::eFeedbackLoopEXT )
result += "FeedbackLoopEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & FramebufferCreateFlagBits::eImageless )
result += "Imageless | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & RenderPassCreateFlagBits::eTransformQCOM )
result += "TransformQCOM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SubpassDescriptionFlagBits::ePerViewAttributesNVX )
result += "PerViewAttributesNVX | ";
if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX )
result += "PerViewPositionXOnlyNVX | ";
if ( value & SubpassDescriptionFlagBits::eFragmentRegionQCOM )
result += "FragmentRegionQCOM | ";
if ( value & SubpassDescriptionFlagBits::eShaderResolveQCOM )
result += "ShaderResolveQCOM | ";
if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessARM )
result += "RasterizationOrderAttachmentColorAccessARM | ";
if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessARM )
result += "RasterizationOrderAttachmentDepthAccessARM | ";
if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessARM )
result += "RasterizationOrderAttachmentStencilAccessARM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & CommandPoolCreateFlagBits::eTransient )
result += "Transient | ";
if ( value & CommandPoolCreateFlagBits::eResetCommandBuffer )
result += "ResetCommandBuffer | ";
if ( value & CommandPoolCreateFlagBits::eProtected )
result += "Protected | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & CommandPoolResetFlagBits::eReleaseResources )
result += "ReleaseResources | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & CommandBufferResetFlagBits::eReleaseResources )
result += "ReleaseResources | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & CommandBufferUsageFlagBits::eOneTimeSubmit )
result += "OneTimeSubmit | ";
if ( value & CommandBufferUsageFlagBits::eRenderPassContinue )
result += "RenderPassContinue | ";
if ( value & CommandBufferUsageFlagBits::eSimultaneousUse )
result += "SimultaneousUse | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & QueryControlFlagBits::ePrecise )
result += "Precise | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & StencilFaceFlagBits::eFront )
result += "Front | ";
if ( value & StencilFaceFlagBits::eBack )
result += "Back | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
//=== VK_VERSION_1_1 ===
VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SubgroupFeatureFlagBits::eBasic )
result += "Basic | ";
if ( value & SubgroupFeatureFlagBits::eVote )
result += "Vote | ";
if ( value & SubgroupFeatureFlagBits::eArithmetic )
result += "Arithmetic | ";
if ( value & SubgroupFeatureFlagBits::eBallot )
result += "Ballot | ";
if ( value & SubgroupFeatureFlagBits::eShuffle )
result += "Shuffle | ";
if ( value & SubgroupFeatureFlagBits::eShuffleRelative )
result += "ShuffleRelative | ";
if ( value & SubgroupFeatureFlagBits::eClustered )
result += "Clustered | ";
if ( value & SubgroupFeatureFlagBits::eQuad )
result += "Quad | ";
if ( value & SubgroupFeatureFlagBits::ePartitionedNV )
result += "PartitionedNV | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PeerMemoryFeatureFlagBits::eCopySrc )
result += "CopySrc | ";
if ( value & PeerMemoryFeatureFlagBits::eCopyDst )
result += "CopyDst | ";
if ( value & PeerMemoryFeatureFlagBits::eGenericSrc )
result += "GenericSrc | ";
if ( value & PeerMemoryFeatureFlagBits::eGenericDst )
result += "GenericDst | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & MemoryAllocateFlagBits::eDeviceMask )
result += "DeviceMask | ";
if ( value & MemoryAllocateFlagBits::eDeviceAddress )
result += "DeviceAddress | ";
if ( value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay )
result += "DeviceAddressCaptureReplay | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd )
result += "OpaqueFd | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 )
result += "OpaqueWin32 | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt )
result += "OpaqueWin32Kmt | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture )
result += "D3D11Texture | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt )
result += "D3D11TextureKmt | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap )
result += "D3D12Heap | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource )
result += "D3D12Resource | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT )
result += "DmaBufEXT | ";
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
if ( value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID )
result += "AndroidHardwareBufferANDROID | ";
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
if ( value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT )
result += "HostAllocationEXT | ";
if ( value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT )
result += "HostMappedForeignMemoryEXT | ";
#if defined( VK_USE_PLATFORM_FUCHSIA )
if ( value & ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA )
result += "ZirconVmoFUCHSIA | ";
#endif /*VK_USE_PLATFORM_FUCHSIA*/
if ( value & ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV )
result += "RdmaAddressNV | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalMemoryFeatureFlagBits::eDedicatedOnly )
result += "DedicatedOnly | ";
if ( value & ExternalMemoryFeatureFlagBits::eExportable )
result += "Exportable | ";
if ( value & ExternalMemoryFeatureFlagBits::eImportable )
result += "Importable | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueFd )
result += "OpaqueFd | ";
if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32 )
result += "OpaqueWin32 | ";
if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt )
result += "OpaqueWin32Kmt | ";
if ( value & ExternalFenceHandleTypeFlagBits::eSyncFd )
result += "SyncFd | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalFenceFeatureFlagBits::eExportable )
result += "Exportable | ";
if ( value & ExternalFenceFeatureFlagBits::eImportable )
result += "Importable | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & FenceImportFlagBits::eTemporary )
result += "Temporary | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SemaphoreImportFlagBits::eTemporary )
result += "Temporary | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd )
result += "OpaqueFd | ";
if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 )
result += "OpaqueWin32 | ";
if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt )
result += "OpaqueWin32Kmt | ";
if ( value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence )
result += "D3D12Fence | ";
if ( value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd )
result += "SyncFd | ";
#if defined( VK_USE_PLATFORM_FUCHSIA )
if ( value & ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA )
result += "ZirconEventFUCHSIA | ";
#endif /*VK_USE_PLATFORM_FUCHSIA*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalSemaphoreFeatureFlagBits::eExportable )
result += "Exportable | ";
if ( value & ExternalSemaphoreFeatureFlagBits::eImportable )
result += "Importable | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
//=== VK_VERSION_1_2 ===
VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DescriptorBindingFlagBits::eUpdateAfterBind )
result += "UpdateAfterBind | ";
if ( value & DescriptorBindingFlagBits::eUpdateUnusedWhilePending )
result += "UpdateUnusedWhilePending | ";
if ( value & DescriptorBindingFlagBits::ePartiallyBound )
result += "PartiallyBound | ";
if ( value & DescriptorBindingFlagBits::eVariableDescriptorCount )
result += "VariableDescriptorCount | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ResolveModeFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ResolveModeFlagBits::eSampleZero )
result += "SampleZero | ";
if ( value & ResolveModeFlagBits::eAverage )
result += "Average | ";
if ( value & ResolveModeFlagBits::eMin )
result += "Min | ";
if ( value & ResolveModeFlagBits::eMax )
result += "Max | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SemaphoreWaitFlagBits::eAny )
result += "Any | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
//=== VK_VERSION_1_3 ===
VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineCreationFeedbackFlagBits::eValid )
result += "Valid | ";
if ( value & PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit )
result += "ApplicationPipelineCacheHit | ";
if ( value & PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration )
result += "BasePipelineAcceleration | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ToolPurposeFlagBits::eValidation )
result += "Validation | ";
if ( value & ToolPurposeFlagBits::eProfiling )
result += "Profiling | ";
if ( value & ToolPurposeFlagBits::eTracing )
result += "Tracing | ";
if ( value & ToolPurposeFlagBits::eAdditionalFeatures )
result += "AdditionalFeatures | ";
if ( value & ToolPurposeFlagBits::eModifyingFeatures )
result += "ModifyingFeatures | ";
if ( value & ToolPurposeFlagBits::eDebugReportingEXT )
result += "DebugReportingEXT | ";
if ( value & ToolPurposeFlagBits::eDebugMarkersEXT )
result += "DebugMarkersEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( PrivateDataSlotCreateFlags )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags2 value )
{
if ( !value )
return "{}";
std::string result;
if ( value & PipelineStageFlagBits2::eTopOfPipe )
result += "TopOfPipe | ";
if ( value & PipelineStageFlagBits2::eDrawIndirect )
result += "DrawIndirect | ";
if ( value & PipelineStageFlagBits2::eVertexInput )
result += "VertexInput | ";
if ( value & PipelineStageFlagBits2::eVertexShader )
result += "VertexShader | ";
if ( value & PipelineStageFlagBits2::eTessellationControlShader )
result += "TessellationControlShader | ";
if ( value & PipelineStageFlagBits2::eTessellationEvaluationShader )
result += "TessellationEvaluationShader | ";
if ( value & PipelineStageFlagBits2::eGeometryShader )
result += "GeometryShader | ";
if ( value & PipelineStageFlagBits2::eFragmentShader )
result += "FragmentShader | ";
if ( value & PipelineStageFlagBits2::eEarlyFragmentTests )
result += "EarlyFragmentTests | ";
if ( value & PipelineStageFlagBits2::eLateFragmentTests )
result += "LateFragmentTests | ";
if ( value & PipelineStageFlagBits2::eColorAttachmentOutput )
result += "ColorAttachmentOutput | ";
if ( value & PipelineStageFlagBits2::eComputeShader )
result += "ComputeShader | ";
if ( value & PipelineStageFlagBits2::eAllTransfer )
result += "AllTransfer | ";
if ( value & PipelineStageFlagBits2::eBottomOfPipe )
result += "BottomOfPipe | ";
if ( value & PipelineStageFlagBits2::eHost )
result += "Host | ";
if ( value & PipelineStageFlagBits2::eAllGraphics )
result += "AllGraphics | ";
if ( value & PipelineStageFlagBits2::eAllCommands )
result += "AllCommands | ";
if ( value & PipelineStageFlagBits2::eCopy )
result += "Copy | ";
if ( value & PipelineStageFlagBits2::eResolve )
result += "Resolve | ";
if ( value & PipelineStageFlagBits2::eBlit )
result += "Blit | ";
if ( value & PipelineStageFlagBits2::eClear )
result += "Clear | ";
if ( value & PipelineStageFlagBits2::eIndexInput )
result += "IndexInput | ";
if ( value & PipelineStageFlagBits2::eVertexAttributeInput )
result += "VertexAttributeInput | ";
if ( value & PipelineStageFlagBits2::ePreRasterizationShaders )
result += "PreRasterizationShaders | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & PipelineStageFlagBits2::eVideoDecodeKHR )
result += "VideoDecodeKHR | ";
if ( value & PipelineStageFlagBits2::eVideoEncodeKHR )
result += "VideoEncodeKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & PipelineStageFlagBits2::eTransformFeedbackEXT )
result += "TransformFeedbackEXT | ";
if ( value & PipelineStageFlagBits2::eConditionalRenderingEXT )
result += "ConditionalRenderingEXT | ";
if ( value & PipelineStageFlagBits2::eCommandPreprocessNV )
result += "CommandPreprocessNV | ";
if ( value & PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR )
result += "FragmentShadingRateAttachmentKHR | ";
if ( value & PipelineStageFlagBits2::eAccelerationStructureBuildKHR )
result += "AccelerationStructureBuildKHR | ";
if ( value & PipelineStageFlagBits2::eRayTracingShaderKHR )
result += "RayTracingShaderKHR | ";
if ( value & PipelineStageFlagBits2::eFragmentDensityProcessEXT )
result += "FragmentDensityProcessEXT | ";
if ( value & PipelineStageFlagBits2::eTaskShaderNV )
result += "TaskShaderNV | ";
if ( value & PipelineStageFlagBits2::eMeshShaderNV )
result += "MeshShaderNV | ";
if ( value & PipelineStageFlagBits2::eSubpassShadingHUAWEI )
result += "SubpassShadingHUAWEI | ";
if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI )
result += "InvocationMaskHUAWEI | ";
if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR )
result += "AccelerationStructureCopyKHR | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( AccessFlags2 value )
{
if ( !value )
return "{}";
std::string result;
if ( value & AccessFlagBits2::eIndirectCommandRead )
result += "IndirectCommandRead | ";
if ( value & AccessFlagBits2::eIndexRead )
result += "IndexRead | ";
if ( value & AccessFlagBits2::eVertexAttributeRead )
result += "VertexAttributeRead | ";
if ( value & AccessFlagBits2::eUniformRead )
result += "UniformRead | ";
if ( value & AccessFlagBits2::eInputAttachmentRead )
result += "InputAttachmentRead | ";
if ( value & AccessFlagBits2::eShaderRead )
result += "ShaderRead | ";
if ( value & AccessFlagBits2::eShaderWrite )
result += "ShaderWrite | ";
if ( value & AccessFlagBits2::eColorAttachmentRead )
result += "ColorAttachmentRead | ";
if ( value & AccessFlagBits2::eColorAttachmentWrite )
result += "ColorAttachmentWrite | ";
if ( value & AccessFlagBits2::eDepthStencilAttachmentRead )
result += "DepthStencilAttachmentRead | ";
if ( value & AccessFlagBits2::eDepthStencilAttachmentWrite )
result += "DepthStencilAttachmentWrite | ";
if ( value & AccessFlagBits2::eTransferRead )
result += "TransferRead | ";
if ( value & AccessFlagBits2::eTransferWrite )
result += "TransferWrite | ";
if ( value & AccessFlagBits2::eHostRead )
result += "HostRead | ";
if ( value & AccessFlagBits2::eHostWrite )
result += "HostWrite | ";
if ( value & AccessFlagBits2::eMemoryRead )
result += "MemoryRead | ";
if ( value & AccessFlagBits2::eMemoryWrite )
result += "MemoryWrite | ";
if ( value & AccessFlagBits2::eShaderSampledRead )
result += "ShaderSampledRead | ";
if ( value & AccessFlagBits2::eShaderStorageRead )
result += "ShaderStorageRead | ";
if ( value & AccessFlagBits2::eShaderStorageWrite )
result += "ShaderStorageWrite | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & AccessFlagBits2::eVideoDecodeReadKHR )
result += "VideoDecodeReadKHR | ";
if ( value & AccessFlagBits2::eVideoDecodeWriteKHR )
result += "VideoDecodeWriteKHR | ";
if ( value & AccessFlagBits2::eVideoEncodeReadKHR )
result += "VideoEncodeReadKHR | ";
if ( value & AccessFlagBits2::eVideoEncodeWriteKHR )
result += "VideoEncodeWriteKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & AccessFlagBits2::eTransformFeedbackWriteEXT )
result += "TransformFeedbackWriteEXT | ";
if ( value & AccessFlagBits2::eTransformFeedbackCounterReadEXT )
result += "TransformFeedbackCounterReadEXT | ";
if ( value & AccessFlagBits2::eTransformFeedbackCounterWriteEXT )
result += "TransformFeedbackCounterWriteEXT | ";
if ( value & AccessFlagBits2::eConditionalRenderingReadEXT )
result += "ConditionalRenderingReadEXT | ";
if ( value & AccessFlagBits2::eCommandPreprocessReadNV )
result += "CommandPreprocessReadNV | ";
if ( value & AccessFlagBits2::eCommandPreprocessWriteNV )
result += "CommandPreprocessWriteNV | ";
if ( value & AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR )
result += "FragmentShadingRateAttachmentReadKHR | ";
if ( value & AccessFlagBits2::eAccelerationStructureReadKHR )
result += "AccelerationStructureReadKHR | ";
if ( value & AccessFlagBits2::eAccelerationStructureWriteKHR )
result += "AccelerationStructureWriteKHR | ";
if ( value & AccessFlagBits2::eFragmentDensityMapReadEXT )
result += "FragmentDensityMapReadEXT | ";
if ( value & AccessFlagBits2::eColorAttachmentReadNoncoherentEXT )
result += "ColorAttachmentReadNoncoherentEXT | ";
if ( value & AccessFlagBits2::eInvocationMaskReadHUAWEI )
result += "InvocationMaskReadHUAWEI | ";
if ( value & AccessFlagBits2::eShaderBindingTableReadKHR )
result += "ShaderBindingTableReadKHR | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( SubmitFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SubmitFlagBits::eProtected )
result += "Protected | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( RenderingFlags value )
{
if ( !value )
return "{}";
std::string result;
if ( value & RenderingFlagBits::eContentsSecondaryCommandBuffers )
result += "ContentsSecondaryCommandBuffers | ";
if ( value & RenderingFlagBits::eSuspending )
result += "Suspending | ";
if ( value & RenderingFlagBits::eResuming )
result += "Resuming | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags2 value )
{
if ( !value )
return "{}";
std::string result;
if ( value & FormatFeatureFlagBits2::eSampledImage )
result += "SampledImage | ";
if ( value & FormatFeatureFlagBits2::eStorageImage )
result += "StorageImage | ";
if ( value & FormatFeatureFlagBits2::eStorageImageAtomic )
result += "StorageImageAtomic | ";
if ( value & FormatFeatureFlagBits2::eUniformTexelBuffer )
result += "UniformTexelBuffer | ";
if ( value & FormatFeatureFlagBits2::eStorageTexelBuffer )
result += "StorageTexelBuffer | ";
if ( value & FormatFeatureFlagBits2::eStorageTexelBufferAtomic )
result += "StorageTexelBufferAtomic | ";
if ( value & FormatFeatureFlagBits2::eVertexBuffer )
result += "VertexBuffer | ";
if ( value & FormatFeatureFlagBits2::eColorAttachment )
result += "ColorAttachment | ";
if ( value & FormatFeatureFlagBits2::eColorAttachmentBlend )
result += "ColorAttachmentBlend | ";
if ( value & FormatFeatureFlagBits2::eDepthStencilAttachment )
result += "DepthStencilAttachment | ";
if ( value & FormatFeatureFlagBits2::eBlitSrc )
result += "BlitSrc | ";
if ( value & FormatFeatureFlagBits2::eBlitDst )
result += "BlitDst | ";
if ( value & FormatFeatureFlagBits2::eSampledImageFilterLinear )
result += "SampledImageFilterLinear | ";
if ( value & FormatFeatureFlagBits2::eSampledImageFilterCubic )
result += "SampledImageFilterCubic | ";
if ( value & FormatFeatureFlagBits2::eTransferSrc )
result += "TransferSrc | ";
if ( value & FormatFeatureFlagBits2::eTransferDst )
result += "TransferDst | ";
if ( value & FormatFeatureFlagBits2::eSampledImageFilterMinmax )
result += "SampledImageFilterMinmax | ";
if ( value & FormatFeatureFlagBits2::eMidpointChromaSamples )
result += "MidpointChromaSamples | ";
if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter )
result += "SampledImageYcbcrConversionLinearFilter | ";
if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter )
result += "SampledImageYcbcrConversionSeparateReconstructionFilter | ";
if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit )
result += "SampledImageYcbcrConversionChromaReconstructionExplicit | ";
if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable )
result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | ";
if ( value & FormatFeatureFlagBits2::eDisjoint )
result += "Disjoint | ";
if ( value & FormatFeatureFlagBits2::eCositedChromaSamples )
result += "CositedChromaSamples | ";
if ( value & FormatFeatureFlagBits2::eStorageReadWithoutFormat )
result += "StorageReadWithoutFormat | ";
if ( value & FormatFeatureFlagBits2::eStorageWriteWithoutFormat )
result += "StorageWriteWithoutFormat | ";
if ( value & FormatFeatureFlagBits2::eSampledImageDepthComparison )
result += "SampledImageDepthComparison | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & FormatFeatureFlagBits2::eVideoDecodeOutputKHR )
result += "VideoDecodeOutputKHR | ";
if ( value & FormatFeatureFlagBits2::eVideoDecodeDpbKHR )
result += "VideoDecodeDpbKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR )
result += "AccelerationStructureVertexBufferKHR | ";
if ( value & FormatFeatureFlagBits2::eFragmentDensityMapEXT )
result += "FragmentDensityMapEXT | ";
if ( value & FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR )
result += "FragmentShadingRateAttachmentKHR | ";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & FormatFeatureFlagBits2::eVideoEncodeInputKHR )
result += "VideoEncodeInputKHR | ";
if ( value & FormatFeatureFlagBits2::eVideoEncodeDpbKHR )
result += "VideoEncodeDpbKHR | ";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & FormatFeatureFlagBits2::eLinearColorAttachmentNV )
result += "LinearColorAttachmentNV | ";
if ( value & FormatFeatureFlagBits2::eWeightImageQCOM )
result += "WeightImageQCOM | ";
if ( value & FormatFeatureFlagBits2::eWeightSampledImageQCOM )
result += "WeightSampledImageQCOM | ";
if ( value & FormatFeatureFlagBits2::eBlockMatchingQCOM )
result += "BlockMatchingQCOM | ";
if ( value & FormatFeatureFlagBits2::eBoxFilterSampledQCOM )
result += "BoxFilterSampledQCOM | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
//=== VK_KHR_surface ===
VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & CompositeAlphaFlagBitsKHR::eOpaque )
result += "Opaque | ";
if ( value & CompositeAlphaFlagBitsKHR::ePreMultiplied )
result += "PreMultiplied | ";
if ( value & CompositeAlphaFlagBitsKHR::ePostMultiplied )
result += "PostMultiplied | ";
if ( value & CompositeAlphaFlagBitsKHR::eInherit )
result += "Inherit | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
//=== VK_KHR_swapchain ===
VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions )
result += "SplitInstanceBindRegions | ";
if ( value & SwapchainCreateFlagBitsKHR::eProtected )
result += "Protected | ";
if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat )
result += "MutableFormat | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocal )
result += "Local | ";
if ( value & DeviceGroupPresentModeFlagBitsKHR::eRemote )
result += "Remote | ";
if ( value & DeviceGroupPresentModeFlagBitsKHR::eSum )
result += "Sum | ";
if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice )
result += "LocalMultiDevice | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
//=== VK_KHR_display ===
VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DisplayPlaneAlphaFlagBitsKHR::eOpaque )
result += "Opaque | ";
if ( value & DisplayPlaneAlphaFlagBitsKHR::eGlobal )
result += "Global | ";
if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel )
result += "PerPixel | ";
if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied )
result += "PerPixelPremultiplied | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & SurfaceTransformFlagBitsKHR::eIdentity )
result += "Identity | ";
if ( value & SurfaceTransformFlagBitsKHR::eRotate90 )
result += "Rotate90 | ";
if ( value & SurfaceTransformFlagBitsKHR::eRotate180 )
result += "Rotate180 | ";
if ( value & SurfaceTransformFlagBitsKHR::eRotate270 )
result += "Rotate270 | ";
if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirror )
result += "HorizontalMirror | ";
if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 )
result += "HorizontalMirrorRotate90 | ";
if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 )
result += "HorizontalMirrorRotate180 | ";
if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 )
result += "HorizontalMirrorRotate270 | ";
if ( value & SurfaceTransformFlagBitsKHR::eInherit )
result += "Inherit | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#if defined( VK_USE_PLATFORM_XLIB_KHR )
//=== VK_KHR_xlib_surface ===
VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagsKHR )
{
return "{}";
}
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
//=== VK_KHR_xcb_surface ===
VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagsKHR )
{
return "{}";
}
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
//=== VK_KHR_wayland_surface ===
VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagsKHR )
{
return "{}";
}
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_KHR_android_surface ===
VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR )
{
return "{}";
}
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
//=== VK_KHR_win32_surface ===
VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagsKHR )
{
return "{}";
}
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
//=== VK_EXT_debug_report ===
VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & DebugReportFlagBitsEXT::eInformation )
result += "Information | ";
if ( value & DebugReportFlagBitsEXT::eWarning )
result += "Warning | ";
if ( value & DebugReportFlagBitsEXT::ePerformanceWarning )
result += "PerformanceWarning | ";
if ( value & DebugReportFlagBitsEXT::eError )
result += "Error | ";
if ( value & DebugReportFlagBitsEXT::eDebug )
result += "Debug | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_queue ===
VULKAN_HPP_INLINE std::string to_string( VideoCodecOperationFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
# if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH264EXT )
result += "EncodeH264EXT | ";
if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH265EXT )
result += "EncodeH265EXT | ";
if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH264EXT )
result += "DecodeH264EXT | ";
if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265EXT )
result += "DecodeH265EXT | ";
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoChromaSubsamplingFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoChromaSubsamplingFlagBitsKHR::eMonochrome )
result += "Monochrome | ";
if ( value & VideoChromaSubsamplingFlagBitsKHR::e420 )
result += "420 | ";
if ( value & VideoChromaSubsamplingFlagBitsKHR::e422 )
result += "422 | ";
if ( value & VideoChromaSubsamplingFlagBitsKHR::e444 )
result += "444 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoComponentBitDepthFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoComponentBitDepthFlagBitsKHR::e8 )
result += "8 | ";
if ( value & VideoComponentBitDepthFlagBitsKHR::e10 )
result += "10 | ";
if ( value & VideoComponentBitDepthFlagBitsKHR::e12 )
result += "12 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoCapabilityFlagBitsKHR::eProtectedContent )
result += "ProtectedContent | ";
if ( value & VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
result += "SeparateReferenceImages | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoSessionCreateFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoSessionCreateFlagBitsKHR::eProtectedContent )
result += "ProtectedContent | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagsKHR )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( VideoEndCodingFlagsKHR )
{
return "{}";
}
VULKAN_HPP_INLINE std::string to_string( VideoCodingControlFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoCodingControlFlagBitsKHR::eReset )
result += "Reset | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoCodingQualityPresetFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoCodingQualityPresetFlagBitsKHR::eNormal )
result += "Normal | ";
if ( value & VideoCodingQualityPresetFlagBitsKHR::ePower )
result += "Power | ";
if ( value & VideoCodingQualityPresetFlagBitsKHR::eQuality )
result += "Quality | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_decode_queue ===
VULKAN_HPP_INLINE std::string to_string( VideoDecodeCapabilityFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide )
result += "DpbAndOutputCoincide | ";
if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct )
result += "DpbAndOutputDistinct | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoDecodeFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoDecodeFlagBitsKHR::eReserved0 )
result += "Reserved0 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_transform_feedback ===
VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT )
{
return "{}";
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h264 ===
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceEnabled )
result += "Direct8X8InferenceEnabled | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDirect8X8InferenceDisabled )
result += "Direct8X8InferenceDisabled | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSeparateColourPlane )
result += "SeparateColourPlane | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eQpprimeYZeroTransformBypass )
result += "QpprimeYZeroTransformBypass | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eScalingLists )
result += "ScalingLists | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance )
result += "HrdCompliance | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset )
result += "ChromaQpOffset | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset )
result += "SecondChromaQpOffset | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::ePicInitQpMinus26 )
result += "PicInitQpMinus26 | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPred )
result += "WeightedPred | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredExplicit )
result += "WeightedBipredExplicit | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBipredImplicit )
result += "WeightedBipredImplicit | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedPredNoTable )
result += "WeightedPredNoTable | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 )
result += "Transform8X8 | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCabac )
result += "Cabac | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCavlc )
result += "Cavlc | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled )
result += "DeblockingFilterDisabled | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled )
result += "DeblockingFilterEnabled | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial )
result += "DeblockingFilterPartial | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDisableDirectSpatialMvPred )
result += "DisableDirectSpatialMvPred | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame )
result += "MultipleSlicePerFrame | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSliceMbCount )
result += "SliceMbCount | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice )
result += "RowUnalignedSlice | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType )
result += "DifferentSliceType | ";
if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List )
result += "BFrameInL1List | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264InputModeFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH264InputModeFlagBitsEXT::eFrame )
result += "Frame | ";
if ( value & VideoEncodeH264InputModeFlagBitsEXT::eSlice )
result += "Slice | ";
if ( value & VideoEncodeH264InputModeFlagBitsEXT::eNonVcl )
result += "NonVcl | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264OutputModeFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eFrame )
result += "Frame | ";
if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eSlice )
result += "Slice | ";
if ( value & VideoEncodeH264OutputModeFlagBitsEXT::eNonVcl )
result += "NonVcl | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlStructureFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH264RateControlStructureFlagBitsEXT::eFlat )
result += "Flat | ";
if ( value & VideoEncodeH264RateControlStructureFlagBitsEXT::eDyadic )
result += "Dyadic | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h265 ===
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSeparateColourPlane )
result += "SeparateColourPlane | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eScalingLists )
result += "ScalingLists | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSampleAdaptiveOffsetEnabled )
result += "SampleAdaptiveOffsetEnabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::ePcmEnable )
result += "PcmEnable | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSpsTemporalMvpEnabled )
result += "SpsTemporalMvpEnabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance )
result += "HrdCompliance | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eInitQpMinus26 )
result += "InitQpMinus26 | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eLog2ParallelMergeLevelMinus2 )
result += "Log2ParallelMergeLevelMinus2 | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSignDataHidingEnabled )
result += "SignDataHidingEnabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipEnabled )
result += "TransformSkipEnabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eTransformSkipDisabled )
result += "TransformSkipDisabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::ePpsSliceChromaQpOffsetsPresent )
result += "PpsSliceChromaQpOffsetsPresent | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPred )
result += "WeightedPred | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eWeightedBipred )
result += "WeightedBipred | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eWeightedPredNoTable )
result += "WeightedPredNoTable | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eTransquantBypassEnabled )
result += "TransquantBypassEnabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eEntropyCodingSyncEnabled )
result += "EntropyCodingSyncEnabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDeblockingFilterOverrideEnabled )
result += "DeblockingFilterOverrideEnabled | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerFrame )
result += "MultipleTilePerFrame | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSlicePerTile )
result += "MultipleSlicePerTile | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilePerSlice )
result += "MultipleTilePerSlice | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eSliceSegmentCtbCount )
result += "SliceSegmentCtbCount | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment )
result += "RowUnalignedSliceSegment | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDependentSliceSegment )
result += "DependentSliceSegment | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceType )
result += "DifferentSliceType | ";
if ( value & VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List )
result += "BFrameInL1List | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265InputModeFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH265InputModeFlagBitsEXT::eFrame )
result += "Frame | ";
if ( value & VideoEncodeH265InputModeFlagBitsEXT::eSliceSegment )
result += "SliceSegment | ";
if ( value & VideoEncodeH265InputModeFlagBitsEXT::eNonVcl )
result += "NonVcl | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265OutputModeFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH265OutputModeFlagBitsEXT::eFrame )
result += "Frame | ";
if ( value & VideoEncodeH265OutputModeFlagBitsEXT::eSliceSegment )
result += "SliceSegment | ";
if ( value & VideoEncodeH265OutputModeFlagBitsEXT::eNonVcl )
result += "NonVcl | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CtbSizeFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e16 )
result += "16 | ";
if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e32 )
result += "32 | ";
if ( value & VideoEncodeH265CtbSizeFlagBitsEXT::e64 )
result += "64 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265TransformBlockSizeFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 )
result += "4 | ";
if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 )
result += "8 | ";
if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 )
result += "16 | ";
if ( value & VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32 )
result += "32 | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlStructureFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeH265RateControlStructureFlagBitsEXT::eFlat )
result += "Flat | ";
if ( value & VideoEncodeH265RateControlStructureFlagBitsEXT::eDyadic )
result += "Dyadic | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_decode_h264 ===
VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines )
result += "InterlacedInterleavedLines | ";
if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes )
result += "InterlacedSeparatePlanes | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_USE_PLATFORM_GGP )
//=== VK_GGP_stream_descriptor_surface ===
VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP )
{
return "{}";
}
#endif /*VK_USE_PLATFORM_GGP*/
//=== VK_NV_external_memory_capabilities ===
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 )
result += "OpaqueWin32 | ";
if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt )
result += "OpaqueWin32Kmt | ";
if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image )
result += "D3D11Image | ";
if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt )
result += "D3D11ImageKmt | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value )
{
if ( !value )
return "{}";
std::string result;
if ( value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly )
result += "DedicatedOnly | ";
if ( value & ExternalMemoryFeatureFlagBitsNV::eExportable )
result += "Exportable | ";
if ( value & ExternalMemoryFea