| // Copyright 2015-2024 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 __cpp_lib_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 ( value & FormatFeatureFlagBits::eVideoDecodeOutputKHR ) |
| result += "VideoDecodeOutputKHR | "; |
| if ( value & FormatFeatureFlagBits::eVideoDecodeDpbKHR ) |
| result += "VideoDecodeDpbKHR | "; |
| 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 ( value & FormatFeatureFlagBits::eVideoEncodeInputKHR ) |
| result += "VideoEncodeInputKHR | "; |
| if ( value & FormatFeatureFlagBits::eVideoEncodeDpbKHR ) |
| result += "VideoEncodeDpbKHR | "; |
| |
| 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::eDescriptorBufferCaptureReplayEXT ) |
| result += "DescriptorBufferCaptureReplayEXT | "; |
| if ( value & ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT ) |
| result += "MultisampledRenderToSingleSampledEXT | "; |
| if ( value & ImageCreateFlagBits::e2DViewCompatibleEXT ) |
| result += "2DViewCompatibleEXT | "; |
| if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM ) |
| result += "FragmentDensityMapOffsetQCOM | "; |
| if ( value & ImageCreateFlagBits::eVideoProfileIndependentKHR ) |
| result += "VideoProfileIndependentKHR | "; |
| |
| 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 ( value & ImageUsageFlagBits::eVideoDecodeDstKHR ) |
| result += "VideoDecodeDstKHR | "; |
| if ( value & ImageUsageFlagBits::eVideoDecodeSrcKHR ) |
| result += "VideoDecodeSrcKHR | "; |
| if ( value & ImageUsageFlagBits::eVideoDecodeDpbKHR ) |
| result += "VideoDecodeDpbKHR | "; |
| if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT ) |
| result += "FragmentDensityMapEXT | "; |
| if ( value & ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) |
| result += "FragmentShadingRateAttachmentKHR | "; |
| if ( value & ImageUsageFlagBits::eHostTransferEXT ) |
| result += "HostTransferEXT | "; |
| if ( value & ImageUsageFlagBits::eVideoEncodeDstKHR ) |
| result += "VideoEncodeDstKHR | "; |
| if ( value & ImageUsageFlagBits::eVideoEncodeSrcKHR ) |
| result += "VideoEncodeSrcKHR | "; |
| if ( value & ImageUsageFlagBits::eVideoEncodeDpbKHR ) |
| result += "VideoEncodeDpbKHR | "; |
| 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 ( value & QueueFlagBits::eVideoDecodeKHR ) |
| result += "VideoDecodeKHR | "; |
| if ( value & QueueFlagBits::eVideoEncodeKHR ) |
| result += "VideoEncodeKHR | "; |
| if ( value & QueueFlagBits::eOpticalFlowNV ) |
| result += "OpticalFlowNV | "; |
| |
| 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 "None"; |
| |
| 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::eFragmentDensityProcessEXT ) |
| result += "FragmentDensityProcessEXT | "; |
| if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR ) |
| result += "FragmentShadingRateAttachmentKHR | "; |
| if ( value & PipelineStageFlagBits::eCommandPreprocessNV ) |
| result += "CommandPreprocessNV | "; |
| if ( value & PipelineStageFlagBits::eTaskShaderEXT ) |
| result += "TaskShaderEXT | "; |
| if ( value & PipelineStageFlagBits::eMeshShaderEXT ) |
| result += "MeshShaderEXT | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & MemoryMapFlagBits::ePlacedEXT ) |
| result += "PlacedEXT | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value ) |
| { |
| if ( !value ) |
| return "None"; |
| |
| 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 | "; |
| if ( value & QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT ) |
| result += "TaskShaderInvocationsEXT | "; |
| if ( value & QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT ) |
| result += "MeshShaderInvocationsEXT | "; |
| if ( value & QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI ) |
| result += "ClusterCullingShaderInvocationsHUAWEI | "; |
| |
| 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 ( value & QueryResultFlagBits::eWithStatusKHR ) |
| result += "WithStatusKHR | "; |
| |
| 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 | "; |
| if ( value & BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT ) |
| result += "DescriptorBufferCaptureReplayEXT | "; |
| if ( value & BufferCreateFlagBits::eVideoProfileIndependentKHR ) |
| result += "VideoProfileIndependentKHR | "; |
| |
| 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 ( value & BufferUsageFlagBits::eVideoDecodeSrcKHR ) |
| result += "VideoDecodeSrcKHR | "; |
| if ( value & BufferUsageFlagBits::eVideoDecodeDstKHR ) |
| result += "VideoDecodeDstKHR | "; |
| if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT ) |
| result += "TransformFeedbackBufferEXT | "; |
| if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) |
| result += "TransformFeedbackCounterBufferEXT | "; |
| if ( value & BufferUsageFlagBits::eConditionalRenderingEXT ) |
| result += "ConditionalRenderingEXT | "; |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) |
| if ( value & BufferUsageFlagBits::eExecutionGraphScratchAMDX ) |
| result += "ExecutionGraphScratchAMDX | "; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| if ( value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR ) |
| result += "AccelerationStructureBuildInputReadOnlyKHR | "; |
| if ( value & BufferUsageFlagBits::eAccelerationStructureStorageKHR ) |
| result += "AccelerationStructureStorageKHR | "; |
| if ( value & BufferUsageFlagBits::eShaderBindingTableKHR ) |
| result += "ShaderBindingTableKHR | "; |
| if ( value & BufferUsageFlagBits::eVideoEncodeDstKHR ) |
| result += "VideoEncodeDstKHR | "; |
| if ( value & BufferUsageFlagBits::eVideoEncodeSrcKHR ) |
| result += "VideoEncodeSrcKHR | "; |
| if ( value & BufferUsageFlagBits::eSamplerDescriptorBufferEXT ) |
| result += "SamplerDescriptorBufferEXT | "; |
| if ( value & BufferUsageFlagBits::eResourceDescriptorBufferEXT ) |
| result += "ResourceDescriptorBufferEXT | "; |
| if ( value & BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT ) |
| result += "PushDescriptorsDescriptorBufferEXT | "; |
| if ( value & BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT ) |
| result += "MicromapBuildInputReadOnlyEXT | "; |
| if ( value & BufferUsageFlagBits::eMicromapStorageEXT ) |
| result += "MicromapStorageEXT | "; |
| |
| 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::eDescriptorBufferCaptureReplayEXT ) |
| result += "DescriptorBufferCaptureReplayEXT | "; |
| 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 "None"; |
| |
| 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::eRasterizationOrderAttachmentAccessEXT ) |
| result += "RasterizationOrderAttachmentAccessEXT | "; |
| |
| 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::eDescriptorBufferEXT ) |
| result += "DescriptorBufferEXT | "; |
| 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 | "; |
| if ( value & PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT ) |
| result += "RayTracingOpacityMicromapEXT | "; |
| #if defined( VK_ENABLE_BETA_EXTENSIONS ) |
| if ( value & PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV ) |
| result += "RayTracingDisplacementMicromapNV | "; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| if ( value & PipelineCreateFlagBits::eNoProtectedAccessEXT ) |
| result += "NoProtectedAccessEXT | "; |
| if ( value & PipelineCreateFlagBits::eProtectedAccessOnlyEXT ) |
| result += "ProtectedAccessOnlyEXT | "; |
| |
| 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::eRasterizationOrderAttachmentDepthAccessEXT ) |
| result += "RasterizationOrderAttachmentDepthAccessEXT | "; |
| if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) |
| result += "RasterizationOrderAttachmentStencilAccessEXT | "; |
| |
| 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::eTaskEXT ) |
| result += "TaskEXT | "; |
| if ( value & ShaderStageFlagBits::eMeshEXT ) |
| result += "MeshEXT | "; |
| if ( value & ShaderStageFlagBits::eSubpassShadingHUAWEI ) |
| result += "SubpassShadingHUAWEI | "; |
| if ( value & ShaderStageFlagBits::eClusterCullingHUAWEI ) |
| result += "ClusterCullingHUAWEI | "; |
| |
| 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::eDescriptorBufferCaptureReplayEXT ) |
| result += "DescriptorBufferCaptureReplayEXT | "; |
| 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::eHostOnlyEXT ) |
| result += "HostOnlyEXT | "; |
| if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV ) |
| result += "AllowOverallocationSetsNV | "; |
| if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV ) |
| result += "AllowOverallocationPoolsNV | "; |
| |
| 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::eDescriptorBufferEXT ) |
| result += "DescriptorBufferEXT | "; |
| if ( value & DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT ) |
| result += "EmbeddedImmutableSamplersEXT | "; |
| if ( value & DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV ) |
| result += "IndirectBindableNV | "; |
| if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT ) |
| result += "HostOnlyPoolEXT | "; |
| if ( value & DescriptorSetLayoutCreateFlagBits::ePerStageNV ) |
| result += "PerStageNV | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( AccessFlags value ) |
| { |
| if ( !value ) |
| return "None"; |
| |
| 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::eRasterizationOrderAttachmentColorAccessEXT ) |
| result += "RasterizationOrderAttachmentColorAccessEXT | "; |
| if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) |
| result += "RasterizationOrderAttachmentDepthAccessEXT | "; |
| if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) |
| result += "RasterizationOrderAttachmentStencilAccessEXT | "; |
| if ( value & SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT ) |
| result += "EnableLegacyDitheringEXT | "; |
| |
| 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 | "; |
| if ( value & SubgroupFeatureFlagBits::eRotateKHR ) |
| result += "RotateKHR | "; |
| if ( value & SubgroupFeatureFlagBits::eRotateClusteredKHR ) |
| result += "RotateClusteredKHR | "; |
| |
| 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 | "; |
| #if defined( VK_USE_PLATFORM_SCREEN_QNX ) |
| if ( value & ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX ) |
| result += "ScreenBufferQNX | "; |
| #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| 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 "None"; |
| |
| 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 | "; |
| #if defined( VK_USE_PLATFORM_ANDROID_KHR ) |
| if ( value & ResolveModeFlagBits::eExternalFormatDownsampleANDROID ) |
| result += "ExternalFormatDownsampleANDROID | "; |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| 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 "None"; |
| |
| 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 ( value & PipelineStageFlagBits2::eVideoDecodeKHR ) |
| result += "VideoDecodeKHR | "; |
| if ( value & PipelineStageFlagBits2::eVideoEncodeKHR ) |
| result += "VideoEncodeKHR | "; |
| 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::eTaskShaderEXT ) |
| result += "TaskShaderEXT | "; |
| if ( value & PipelineStageFlagBits2::eMeshShaderEXT ) |
| result += "MeshShaderEXT | "; |
| if ( value & PipelineStageFlagBits2::eSubpassShaderHUAWEI ) |
| result += "SubpassShaderHUAWEI | "; |
| if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI ) |
| result += "InvocationMaskHUAWEI | "; |
| if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR ) |
| result += "AccelerationStructureCopyKHR | "; |
| if ( value & PipelineStageFlagBits2::eMicromapBuildEXT ) |
| result += "MicromapBuildEXT | "; |
| if ( value & PipelineStageFlagBits2::eClusterCullingShaderHUAWEI ) |
| result += "ClusterCullingShaderHUAWEI | "; |
| if ( value & PipelineStageFlagBits2::eOpticalFlowNV ) |
| result += "OpticalFlowNV | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( AccessFlags2 value ) |
| { |
| if ( !value ) |
| return "None"; |
| |
| 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 ( value & AccessFlagBits2::eVideoDecodeReadKHR ) |
| result += "VideoDecodeReadKHR | "; |
| if ( value & AccessFlagBits2::eVideoDecodeWriteKHR ) |
| result += "VideoDecodeWriteKHR | "; |
| if ( value & AccessFlagBits2::eVideoEncodeReadKHR ) |
| result += "VideoEncodeReadKHR | "; |
| if ( value & AccessFlagBits2::eVideoEncodeWriteKHR ) |
| result += "VideoEncodeWriteKHR | "; |
| 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::eDescriptorBufferReadEXT ) |
| result += "DescriptorBufferReadEXT | "; |
| if ( value & AccessFlagBits2::eInvocationMaskReadHUAWEI ) |
| result += "InvocationMaskReadHUAWEI | "; |
| if ( value & AccessFlagBits2::eShaderBindingTableReadKHR ) |
| result += "ShaderBindingTableReadKHR | "; |
| if ( value & AccessFlagBits2::eMicromapReadEXT ) |
| result += "MicromapReadEXT | "; |
| if ( value & AccessFlagBits2::eMicromapWriteEXT ) |
| result += "MicromapWriteEXT | "; |
| if ( value & AccessFlagBits2::eOpticalFlowReadNV ) |
| result += "OpticalFlowReadNV | "; |
| if ( value & AccessFlagBits2::eOpticalFlowWriteNV ) |
| result += "OpticalFlowWriteNV | "; |
| |
| 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 | "; |
| if ( value & RenderingFlagBits::eContentsInlineEXT ) |
| result += "ContentsInlineEXT | "; |
| if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT ) |
| result += "EnableLegacyDitheringEXT | "; |
| |
| 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 ( value & FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) |
| result += "VideoDecodeOutputKHR | "; |
| if ( value & FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) |
| result += "VideoDecodeDpbKHR | "; |
| if ( value & FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) |
| result += "AccelerationStructureVertexBufferKHR | "; |
| if ( value & FormatFeatureFlagBits2::eFragmentDensityMapEXT ) |
| result += "FragmentDensityMapEXT | "; |
| if ( value & FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR ) |
| result += "FragmentShadingRateAttachmentKHR | "; |
| if ( value & FormatFeatureFlagBits2::eHostImageTransferEXT ) |
| result += "HostImageTransferEXT | "; |
| if ( value & FormatFeatureFlagBits2::eVideoEncodeInputKHR ) |
| result += "VideoEncodeInputKHR | "; |
| if ( value & FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) |
| result += "VideoEncodeDpbKHR | "; |
| 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 | "; |
| if ( value & FormatFeatureFlagBits2::eOpticalFlowImageNV ) |
| result += "OpticalFlowImageNV | "; |
| if ( value & FormatFeatureFlagBits2::eOpticalFlowVectorNV ) |
| result += "OpticalFlowVectorNV | "; |
| if ( value & FormatFeatureFlagBits2::eOpticalFlowCostNV ) |
| result += "OpticalFlowCostNV | "; |
| |
| 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 | "; |
| if ( value & SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocationEXT ) |
| result += "DeferredMemoryAllocationEXT | "; |
| |
| 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 ) + " }"; |
| } |
| |
| //=== VK_KHR_video_queue === |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoCodecOperationFlagsKHR value ) |
| { |
| if ( !value ) |
| return "None"; |
| |
| std::string result; |
| if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH264 ) |
| result += "EncodeH264 | "; |
| if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH265 ) |
| result += "EncodeH265 | "; |
| if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH264 ) |
| result += "DecodeH264 | "; |
| if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265 ) |
| result += "DecodeH265 | "; |
| if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 ) |
| result += "DecodeAv1 | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoChromaSubsamplingFlagsKHR value ) |
| { |
| if ( !value ) |
| return "Invalid"; |
| |
| 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 "Invalid"; |
| |
| 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 | "; |
| if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations ) |
| result += "AllowEncodeParameterOptimizations | "; |
| if ( value & VideoSessionCreateFlagBitsKHR::eInlineQueries ) |
| result += "InlineQueries | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagsKHR ) |
| { |
| return "{}"; |
| } |
| |
| 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 | "; |
| if ( value & VideoCodingControlFlagBitsKHR::eEncodeRateControl ) |
| result += "EncodeRateControl | "; |
| if ( value & VideoCodingControlFlagBitsKHR::eEncodeQualityLevel ) |
| result += "EncodeQualityLevel | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| //=== 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( VideoDecodeUsageFlagsKHR value ) |
| { |
| if ( !value ) |
| return "Default"; |
| |
| std::string result; |
| if ( value & VideoDecodeUsageFlagBitsKHR::eTranscoding ) |
| result += "Transcoding | "; |
| if ( value & VideoDecodeUsageFlagBitsKHR::eOffline ) |
| result += "Offline | "; |
| if ( value & VideoDecodeUsageFlagBitsKHR::eStreaming ) |
| result += "Streaming | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoDecodeFlagsKHR ) |
| { |
| return "{}"; |
| } |
| |
| //=== VK_EXT_transform_feedback === |
| |
| VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT ) |
| { |
| return "{}"; |
| } |
| |
| //=== VK_KHR_video_encode_h264 === |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance ) |
| result += "HrdCompliance | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated ) |
| result += "PredictionWeightTableGenerated | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice ) |
| result += "RowUnalignedSlice | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType ) |
| result += "DifferentSliceType | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List ) |
| result += "BFrameInL0List | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List ) |
| result += "BFrameInL1List | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp ) |
| result += "PerPictureTypeMinMaxQp | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp ) |
| result += "PerSliceConstantQp | "; |
| if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu ) |
| result += "GeneratePrefixNalu | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264StdFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet ) |
| result += "SeparateColorPlaneFlagSet | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet ) |
| result += "QpprimeYZeroTransformBypassFlagSet | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet ) |
| result += "ScalingMatrixPresentFlagSet | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset ) |
| result += "ChromaQpIndexOffset | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset ) |
| result += "SecondChromaQpIndexOffset | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 ) |
| result += "PicInitQpMinus26 | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet ) |
| result += "WeightedPredFlagSet | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit ) |
| result += "WeightedBipredIdcExplicit | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit ) |
| result += "WeightedBipredIdcImplicit | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet ) |
| result += "Transform8X8ModeFlagSet | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset ) |
| result += "DirectSpatialMvPredFlagUnset | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset ) |
| result += "EntropyCodingModeFlagUnset | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet ) |
| result += "EntropyCodingModeFlagSet | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset ) |
| result += "Direct8X8InferenceFlagUnset | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet ) |
| result += "ConstrainedIntraPredFlagSet | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled ) |
| result += "DeblockingFilterDisabled | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled ) |
| result += "DeblockingFilterEnabled | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial ) |
| result += "DeblockingFilterPartial | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta ) |
| result += "SliceQpDelta | "; |
| if ( value & VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta ) |
| result += "DifferentSliceQpDelta | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance ) |
| result += "AttemptHrdCompliance | "; |
| if ( value & VideoEncodeH264RateControlFlagBitsKHR::eRegularGop ) |
| result += "RegularGop | "; |
| if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat ) |
| result += "ReferencePatternFlat | "; |
| if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic ) |
| result += "ReferencePatternDyadic | "; |
| if ( value & VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic ) |
| result += "TemporalLayerPatternDyadic | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| //=== VK_KHR_video_encode_h265 === |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance ) |
| result += "HrdCompliance | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated ) |
| result += "PredictionWeightTableGenerated | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment ) |
| result += "RowUnalignedSliceSegment | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType ) |
| result += "DifferentSliceSegmentType | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List ) |
| result += "BFrameInL0List | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List ) |
| result += "BFrameInL1List | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp ) |
| result += "PerPictureTypeMinMaxQp | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp ) |
| result += "PerSliceSegmentConstantQp | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment ) |
| result += "MultipleTilesPerSliceSegment | "; |
| if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile ) |
| result += "MultipleSliceSegmentsPerTile | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265StdFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet ) |
| result += "SeparateColorPlaneFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet ) |
| result += "SampleAdaptiveOffsetEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet ) |
| result += "ScalingListDataPresentFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet ) |
| result += "PcmEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet ) |
| result += "SpsTemporalMvpEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 ) |
| result += "InitQpMinus26 | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet ) |
| result += "WeightedPredFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet ) |
| result += "WeightedBipredFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 ) |
| result += "Log2ParallelMergeLevelMinus2 | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet ) |
| result += "SignDataHidingEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet ) |
| result += "TransformSkipEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset ) |
| result += "TransformSkipEnabledFlagUnset | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet ) |
| result += "PpsSliceChromaQpOffsetsPresentFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet ) |
| result += "TransquantBypassEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet ) |
| result += "ConstrainedIntraPredFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet ) |
| result += "EntropyCodingSyncEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet ) |
| result += "DeblockingFilterOverrideEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet ) |
| result += "DependentSliceSegmentsEnabledFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet ) |
| result += "DependentSliceSegmentFlagSet | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta ) |
| result += "SliceQpDelta | "; |
| if ( value & VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta ) |
| result += "DifferentSliceQpDelta | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CtbSizeFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e16 ) |
| result += "16 | "; |
| if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e32 ) |
| result += "32 | "; |
| if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e64 ) |
| result += "64 | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265TransformBlockSizeFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 ) |
| result += "4 | "; |
| if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 ) |
| result += "8 | "; |
| if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16 ) |
| result += "16 | "; |
| if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32 ) |
| result += "32 | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance ) |
| result += "AttemptHrdCompliance | "; |
| if ( value & VideoEncodeH265RateControlFlagBitsKHR::eRegularGop ) |
| result += "RegularGop | "; |
| if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat ) |
| result += "ReferencePatternFlat | "; |
| if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic ) |
| result += "ReferencePatternDyadic | "; |
| if ( value & VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic ) |
| result += "TemporalSubLayerPatternDyadic | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| //=== VK_KHR_video_decode_h264 === |
| |
| VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsKHR value ) |
| { |
| if ( !value ) |
| return "Progressive"; |
| |
| std::string result; |
| if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines ) |
| result += "InterlacedInterleavedLines | "; |
| if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes ) |
| result += "InterlacedSeparatePlanes | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| #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 & ExternalMemoryFeatureFlagBitsNV::eImportable ) |
| result += "Importable | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| #if defined( VK_USE_PLATFORM_VI_NN ) |
| //=== VK_NN_vi_surface === |
| |
| VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagsNN ) |
| { |
| return "{}"; |
| } |
| #endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| //=== VK_EXT_conditional_rendering === |
| |
| VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & ConditionalRenderingFlagBitsEXT::eInverted ) |
| result += "Inverted | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| //=== VK_EXT_display_surface_counter === |
| |
| VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & SurfaceCounterFlagBitsEXT::eVblank ) |
| result += "Vblank | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| //=== VK_NV_viewport_swizzle === |
| |
| VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV ) |
| { |
| return "{}"; |
| } |
| |
| //=== VK_EXT_discard_rectangles === |
| |
| VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT ) |
| { |
| return "{}"; |
| } |
| |
| //=== VK_EXT_conservative_rasterization === |
| |
| VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT ) |
| { |
| return "{}"; |
| } |
| |
| //=== VK_EXT_depth_clip_enable === |
| |
| VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT ) |
| { |
| return "{}"; |
| } |
| |
| //=== VK_KHR_performance_query === |
| |
| VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting ) |
| result += "PerformanceImpacting | "; |
| if ( value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted ) |
| result += "ConcurrentlyImpacted | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagsKHR ) |
| { |
| return "{}"; |
| } |
| |
| #if defined( VK_USE_PLATFORM_IOS_MVK ) |
| //=== VK_MVK_ios_surface === |
| |
| VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagsMVK ) |
| { |
| return "{}"; |
| } |
| #endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| #if defined( VK_USE_PLATFORM_MACOS_MVK ) |
| //=== VK_MVK_macos_surface === |
| |
| VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagsMVK ) |
| { |
| return "{}"; |
| } |
| #endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| //=== VK_EXT_debug_utils === |
| |
| VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose ) |
| result += "Verbose | "; |
| if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo ) |
| result += "Info | "; |
| if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning ) |
| result += "Warning | "; |
| if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eError ) |
| result += "Error | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value ) |
| { |
| if ( !value ) |
| return "{}"; |
| |
| std::string result; |
| if ( value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral ) |
| result += "General | "; |
| if ( value & DebugUtilsMessageTypeFlagBitsEXT::eValidation ) |
| result += "Validation | "; |
| if ( value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance ) |
| result += "Performance | "; |
| if ( value & DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding ) |
| result += "DeviceAddressBinding | "; |
| |
| return "{ " + result.substr( 0, result.size() - 3 ) + " }"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT ) |
| { |
| return "{}"; |
| } |
| |
| VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT ) |
| { |
| return "{}"; |
| } |
| |
| //=== VK_NV_fragment_coverage_to_color === |
| |
| VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagsNV ) |
| { |
| return "{}"; |
| <
|
