7774 lines
366 KiB
C++
7774 lines
366 KiB
C++
// Copyright 2015-2023 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_FROM_STRING_HPP
|
|
#define VULKAN_FROM_STRING_HPP
|
|
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vulkan/vulkan_enums.hpp>
|
|
|
|
namespace VULKAN_HPP_NAMESPACE
|
|
{
|
|
#define VULKAN_HPP_ENUM_FROM_STRING_STORAGE \
|
|
namespace VULKAN_HPP_NAMESPACE \
|
|
{ \
|
|
VULKAN_HPP_STORAGE_API const ::VULKAN_HPP_NAMESPACE::EnumFromStringMap enumFromStringMap; \
|
|
}
|
|
|
|
//=========================
|
|
//=== ENUMs from_string ===
|
|
//=========================
|
|
|
|
struct EnumFromStringMap
|
|
{
|
|
//=== VK_VERSION_1_0 ===
|
|
|
|
std::unordered_map<std::string, Result> ResultEntries = {
|
|
{ "Success", Result::eSuccess },
|
|
{ "NotReady", Result::eNotReady },
|
|
{ "Timeout", Result::eTimeout },
|
|
{ "EventSet", Result::eEventSet },
|
|
{ "EventReset", Result::eEventReset },
|
|
{ "Incomplete", Result::eIncomplete },
|
|
{ "ErrorOutOfHostMemory", Result::eErrorOutOfHostMemory },
|
|
{ "ErrorOutOfDeviceMemory", Result::eErrorOutOfDeviceMemory },
|
|
{ "ErrorInitializationFailed", Result::eErrorInitializationFailed },
|
|
{ "ErrorDeviceLost", Result::eErrorDeviceLost },
|
|
{ "ErrorMemoryMapFailed", Result::eErrorMemoryMapFailed },
|
|
{ "ErrorLayerNotPresent", Result::eErrorLayerNotPresent },
|
|
{ "ErrorExtensionNotPresent", Result::eErrorExtensionNotPresent },
|
|
{ "ErrorFeatureNotPresent", Result::eErrorFeatureNotPresent },
|
|
{ "ErrorIncompatibleDriver", Result::eErrorIncompatibleDriver },
|
|
{ "ErrorTooManyObjects", Result::eErrorTooManyObjects },
|
|
{ "ErrorFormatNotSupported", Result::eErrorFormatNotSupported },
|
|
{ "ErrorFragmentedPool", Result::eErrorFragmentedPool },
|
|
{ "ErrorUnknown", Result::eErrorUnknown },
|
|
{ "ErrorOutOfPoolMemory", Result::eErrorOutOfPoolMemory },
|
|
{ "ErrorInvalidExternalHandle", Result::eErrorInvalidExternalHandle },
|
|
{ "ErrorFragmentation", Result::eErrorFragmentation },
|
|
{ "ErrorInvalidOpaqueCaptureAddress", Result::eErrorInvalidOpaqueCaptureAddress },
|
|
{ "PipelineCompileRequired", Result::ePipelineCompileRequired },
|
|
{ "ErrorSurfaceLostKHR", Result::eErrorSurfaceLostKHR },
|
|
{ "ErrorNativeWindowInUseKHR", Result::eErrorNativeWindowInUseKHR },
|
|
{ "SuboptimalKHR", Result::eSuboptimalKHR },
|
|
{ "ErrorOutOfDateKHR", Result::eErrorOutOfDateKHR },
|
|
{ "ErrorIncompatibleDisplayKHR", Result::eErrorIncompatibleDisplayKHR },
|
|
{ "ErrorValidationFailedEXT", Result::eErrorValidationFailedEXT },
|
|
{ "ErrorInvalidShaderNV", Result::eErrorInvalidShaderNV },
|
|
{ "ErrorImageUsageNotSupportedKHR", Result::eErrorImageUsageNotSupportedKHR },
|
|
{ "ErrorVideoPictureLayoutNotSupportedKHR", Result::eErrorVideoPictureLayoutNotSupportedKHR },
|
|
{ "ErrorVideoProfileOperationNotSupportedKHR", Result::eErrorVideoProfileOperationNotSupportedKHR },
|
|
{ "ErrorVideoProfileFormatNotSupportedKHR", Result::eErrorVideoProfileFormatNotSupportedKHR },
|
|
{ "ErrorVideoProfileCodecNotSupportedKHR", Result::eErrorVideoProfileCodecNotSupportedKHR },
|
|
{ "ErrorVideoStdVersionNotSupportedKHR", Result::eErrorVideoStdVersionNotSupportedKHR },
|
|
{ "ErrorInvalidDrmFormatModifierPlaneLayoutEXT", Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT },
|
|
{ "ErrorNotPermittedKHR", Result::eErrorNotPermittedKHR },
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
{ "ErrorFullScreenExclusiveModeLostEXT", Result::eErrorFullScreenExclusiveModeLostEXT },
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
{ "ThreadIdleKHR", Result::eThreadIdleKHR },
|
|
{ "ThreadDoneKHR", Result::eThreadDoneKHR },
|
|
{ "OperationDeferredKHR", Result::eOperationDeferredKHR },
|
|
{ "OperationNotDeferredKHR", Result::eOperationNotDeferredKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "ErrorInvalidVideoStdParametersKHR", Result::eErrorInvalidVideoStdParametersKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "ErrorCompressionExhaustedEXT", Result::eErrorCompressionExhaustedEXT },
|
|
{ "ErrorIncompatibleShaderBinaryEXT", Result::eErrorIncompatibleShaderBinaryEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, StructureType> StructureTypeEntries = {
|
|
{ "ApplicationInfo", StructureType::eApplicationInfo },
|
|
{ "InstanceCreateInfo", StructureType::eInstanceCreateInfo },
|
|
{ "DeviceQueueCreateInfo", StructureType::eDeviceQueueCreateInfo },
|
|
{ "DeviceCreateInfo", StructureType::eDeviceCreateInfo },
|
|
{ "SubmitInfo", StructureType::eSubmitInfo },
|
|
{ "MemoryAllocateInfo", StructureType::eMemoryAllocateInfo },
|
|
{ "MappedMemoryRange", StructureType::eMappedMemoryRange },
|
|
{ "BindSparseInfo", StructureType::eBindSparseInfo },
|
|
{ "FenceCreateInfo", StructureType::eFenceCreateInfo },
|
|
{ "SemaphoreCreateInfo", StructureType::eSemaphoreCreateInfo },
|
|
{ "EventCreateInfo", StructureType::eEventCreateInfo },
|
|
{ "QueryPoolCreateInfo", StructureType::eQueryPoolCreateInfo },
|
|
{ "BufferCreateInfo", StructureType::eBufferCreateInfo },
|
|
{ "BufferViewCreateInfo", StructureType::eBufferViewCreateInfo },
|
|
{ "ImageCreateInfo", StructureType::eImageCreateInfo },
|
|
{ "ImageViewCreateInfo", StructureType::eImageViewCreateInfo },
|
|
{ "ShaderModuleCreateInfo", StructureType::eShaderModuleCreateInfo },
|
|
{ "PipelineCacheCreateInfo", StructureType::ePipelineCacheCreateInfo },
|
|
{ "PipelineShaderStageCreateInfo", StructureType::ePipelineShaderStageCreateInfo },
|
|
{ "PipelineVertexInputStateCreateInfo", StructureType::ePipelineVertexInputStateCreateInfo },
|
|
{ "PipelineInputAssemblyStateCreateInfo", StructureType::ePipelineInputAssemblyStateCreateInfo },
|
|
{ "PipelineTessellationStateCreateInfo", StructureType::ePipelineTessellationStateCreateInfo },
|
|
{ "PipelineViewportStateCreateInfo", StructureType::ePipelineViewportStateCreateInfo },
|
|
{ "PipelineRasterizationStateCreateInfo", StructureType::ePipelineRasterizationStateCreateInfo },
|
|
{ "PipelineMultisampleStateCreateInfo", StructureType::ePipelineMultisampleStateCreateInfo },
|
|
{ "PipelineDepthStencilStateCreateInfo", StructureType::ePipelineDepthStencilStateCreateInfo },
|
|
{ "PipelineColorBlendStateCreateInfo", StructureType::ePipelineColorBlendStateCreateInfo },
|
|
{ "PipelineDynamicStateCreateInfo", StructureType::ePipelineDynamicStateCreateInfo },
|
|
{ "GraphicsPipelineCreateInfo", StructureType::eGraphicsPipelineCreateInfo },
|
|
{ "ComputePipelineCreateInfo", StructureType::eComputePipelineCreateInfo },
|
|
{ "PipelineLayoutCreateInfo", StructureType::ePipelineLayoutCreateInfo },
|
|
{ "SamplerCreateInfo", StructureType::eSamplerCreateInfo },
|
|
{ "DescriptorSetLayoutCreateInfo", StructureType::eDescriptorSetLayoutCreateInfo },
|
|
{ "DescriptorPoolCreateInfo", StructureType::eDescriptorPoolCreateInfo },
|
|
{ "DescriptorSetAllocateInfo", StructureType::eDescriptorSetAllocateInfo },
|
|
{ "WriteDescriptorSet", StructureType::eWriteDescriptorSet },
|
|
{ "CopyDescriptorSet", StructureType::eCopyDescriptorSet },
|
|
{ "FramebufferCreateInfo", StructureType::eFramebufferCreateInfo },
|
|
{ "RenderPassCreateInfo", StructureType::eRenderPassCreateInfo },
|
|
{ "CommandPoolCreateInfo", StructureType::eCommandPoolCreateInfo },
|
|
{ "CommandBufferAllocateInfo", StructureType::eCommandBufferAllocateInfo },
|
|
{ "CommandBufferInheritanceInfo", StructureType::eCommandBufferInheritanceInfo },
|
|
{ "CommandBufferBeginInfo", StructureType::eCommandBufferBeginInfo },
|
|
{ "RenderPassBeginInfo", StructureType::eRenderPassBeginInfo },
|
|
{ "BufferMemoryBarrier", StructureType::eBufferMemoryBarrier },
|
|
{ "ImageMemoryBarrier", StructureType::eImageMemoryBarrier },
|
|
{ "MemoryBarrier", StructureType::eMemoryBarrier },
|
|
{ "LoaderInstanceCreateInfo", StructureType::eLoaderInstanceCreateInfo },
|
|
{ "LoaderDeviceCreateInfo", StructureType::eLoaderDeviceCreateInfo },
|
|
{ "PhysicalDeviceSubgroupProperties", StructureType::ePhysicalDeviceSubgroupProperties },
|
|
{ "BindBufferMemoryInfo", StructureType::eBindBufferMemoryInfo },
|
|
{ "BindImageMemoryInfo", StructureType::eBindImageMemoryInfo },
|
|
{ "PhysicalDevice16BitStorageFeatures", StructureType::ePhysicalDevice16BitStorageFeatures },
|
|
{ "MemoryDedicatedRequirements", StructureType::eMemoryDedicatedRequirements },
|
|
{ "MemoryDedicatedAllocateInfo", StructureType::eMemoryDedicatedAllocateInfo },
|
|
{ "MemoryAllocateFlagsInfo", StructureType::eMemoryAllocateFlagsInfo },
|
|
{ "DeviceGroupRenderPassBeginInfo", StructureType::eDeviceGroupRenderPassBeginInfo },
|
|
{ "DeviceGroupCommandBufferBeginInfo", StructureType::eDeviceGroupCommandBufferBeginInfo },
|
|
{ "DeviceGroupSubmitInfo", StructureType::eDeviceGroupSubmitInfo },
|
|
{ "DeviceGroupBindSparseInfo", StructureType::eDeviceGroupBindSparseInfo },
|
|
{ "BindBufferMemoryDeviceGroupInfo", StructureType::eBindBufferMemoryDeviceGroupInfo },
|
|
{ "BindImageMemoryDeviceGroupInfo", StructureType::eBindImageMemoryDeviceGroupInfo },
|
|
{ "PhysicalDeviceGroupProperties", StructureType::ePhysicalDeviceGroupProperties },
|
|
{ "DeviceGroupDeviceCreateInfo", StructureType::eDeviceGroupDeviceCreateInfo },
|
|
{ "BufferMemoryRequirementsInfo2", StructureType::eBufferMemoryRequirementsInfo2 },
|
|
{ "ImageMemoryRequirementsInfo2", StructureType::eImageMemoryRequirementsInfo2 },
|
|
{ "ImageSparseMemoryRequirementsInfo2", StructureType::eImageSparseMemoryRequirementsInfo2 },
|
|
{ "MemoryRequirements2", StructureType::eMemoryRequirements2 },
|
|
{ "SparseImageMemoryRequirements2", StructureType::eSparseImageMemoryRequirements2 },
|
|
{ "PhysicalDeviceFeatures2", StructureType::ePhysicalDeviceFeatures2 },
|
|
{ "PhysicalDeviceProperties2", StructureType::ePhysicalDeviceProperties2 },
|
|
{ "FormatProperties2", StructureType::eFormatProperties2 },
|
|
{ "ImageFormatProperties2", StructureType::eImageFormatProperties2 },
|
|
{ "PhysicalDeviceImageFormatInfo2", StructureType::ePhysicalDeviceImageFormatInfo2 },
|
|
{ "QueueFamilyProperties2", StructureType::eQueueFamilyProperties2 },
|
|
{ "PhysicalDeviceMemoryProperties2", StructureType::ePhysicalDeviceMemoryProperties2 },
|
|
{ "SparseImageFormatProperties2", StructureType::eSparseImageFormatProperties2 },
|
|
{ "PhysicalDeviceSparseImageFormatInfo2", StructureType::ePhysicalDeviceSparseImageFormatInfo2 },
|
|
{ "PhysicalDevicePointClippingProperties", StructureType::ePhysicalDevicePointClippingProperties },
|
|
{ "RenderPassInputAttachmentAspectCreateInfo", StructureType::eRenderPassInputAttachmentAspectCreateInfo },
|
|
{ "ImageViewUsageCreateInfo", StructureType::eImageViewUsageCreateInfo },
|
|
{ "PipelineTessellationDomainOriginStateCreateInfo", StructureType::ePipelineTessellationDomainOriginStateCreateInfo },
|
|
{ "RenderPassMultiviewCreateInfo", StructureType::eRenderPassMultiviewCreateInfo },
|
|
{ "PhysicalDeviceMultiviewFeatures", StructureType::ePhysicalDeviceMultiviewFeatures },
|
|
{ "PhysicalDeviceMultiviewProperties", StructureType::ePhysicalDeviceMultiviewProperties },
|
|
{ "PhysicalDeviceVariablePointersFeatures", StructureType::ePhysicalDeviceVariablePointersFeatures },
|
|
{ "ProtectedSubmitInfo", StructureType::eProtectedSubmitInfo },
|
|
{ "PhysicalDeviceProtectedMemoryFeatures", StructureType::ePhysicalDeviceProtectedMemoryFeatures },
|
|
{ "PhysicalDeviceProtectedMemoryProperties", StructureType::ePhysicalDeviceProtectedMemoryProperties },
|
|
{ "DeviceQueueInfo2", StructureType::eDeviceQueueInfo2 },
|
|
{ "SamplerYcbcrConversionCreateInfo", StructureType::eSamplerYcbcrConversionCreateInfo },
|
|
{ "SamplerYcbcrConversionInfo", StructureType::eSamplerYcbcrConversionInfo },
|
|
{ "BindImagePlaneMemoryInfo", StructureType::eBindImagePlaneMemoryInfo },
|
|
{ "ImagePlaneMemoryRequirementsInfo", StructureType::eImagePlaneMemoryRequirementsInfo },
|
|
{ "PhysicalDeviceSamplerYcbcrConversionFeatures", StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures },
|
|
{ "SamplerYcbcrConversionImageFormatProperties", StructureType::eSamplerYcbcrConversionImageFormatProperties },
|
|
{ "DescriptorUpdateTemplateCreateInfo", StructureType::eDescriptorUpdateTemplateCreateInfo },
|
|
{ "PhysicalDeviceExternalImageFormatInfo", StructureType::ePhysicalDeviceExternalImageFormatInfo },
|
|
{ "ExternalImageFormatProperties", StructureType::eExternalImageFormatProperties },
|
|
{ "PhysicalDeviceExternalBufferInfo", StructureType::ePhysicalDeviceExternalBufferInfo },
|
|
{ "ExternalBufferProperties", StructureType::eExternalBufferProperties },
|
|
{ "PhysicalDeviceIdProperties", StructureType::ePhysicalDeviceIdProperties },
|
|
{ "ExternalMemoryBufferCreateInfo", StructureType::eExternalMemoryBufferCreateInfo },
|
|
{ "ExternalMemoryImageCreateInfo", StructureType::eExternalMemoryImageCreateInfo },
|
|
{ "ExportMemoryAllocateInfo", StructureType::eExportMemoryAllocateInfo },
|
|
{ "PhysicalDeviceExternalFenceInfo", StructureType::ePhysicalDeviceExternalFenceInfo },
|
|
{ "ExternalFenceProperties", StructureType::eExternalFenceProperties },
|
|
{ "ExportFenceCreateInfo", StructureType::eExportFenceCreateInfo },
|
|
{ "ExportSemaphoreCreateInfo", StructureType::eExportSemaphoreCreateInfo },
|
|
{ "PhysicalDeviceExternalSemaphoreInfo", StructureType::ePhysicalDeviceExternalSemaphoreInfo },
|
|
{ "ExternalSemaphoreProperties", StructureType::eExternalSemaphoreProperties },
|
|
{ "PhysicalDeviceMaintenance3Properties", StructureType::ePhysicalDeviceMaintenance3Properties },
|
|
{ "DescriptorSetLayoutSupport", StructureType::eDescriptorSetLayoutSupport },
|
|
{ "PhysicalDeviceShaderDrawParametersFeatures", StructureType::ePhysicalDeviceShaderDrawParametersFeatures },
|
|
{ "PhysicalDeviceVulkan11Features", StructureType::ePhysicalDeviceVulkan11Features },
|
|
{ "PhysicalDeviceVulkan11Properties", StructureType::ePhysicalDeviceVulkan11Properties },
|
|
{ "PhysicalDeviceVulkan12Features", StructureType::ePhysicalDeviceVulkan12Features },
|
|
{ "PhysicalDeviceVulkan12Properties", StructureType::ePhysicalDeviceVulkan12Properties },
|
|
{ "ImageFormatListCreateInfo", StructureType::eImageFormatListCreateInfo },
|
|
{ "AttachmentDescription2", StructureType::eAttachmentDescription2 },
|
|
{ "AttachmentReference2", StructureType::eAttachmentReference2 },
|
|
{ "SubpassDescription2", StructureType::eSubpassDescription2 },
|
|
{ "SubpassDependency2", StructureType::eSubpassDependency2 },
|
|
{ "RenderPassCreateInfo2", StructureType::eRenderPassCreateInfo2 },
|
|
{ "SubpassBeginInfo", StructureType::eSubpassBeginInfo },
|
|
{ "SubpassEndInfo", StructureType::eSubpassEndInfo },
|
|
{ "PhysicalDevice8BitStorageFeatures", StructureType::ePhysicalDevice8BitStorageFeatures },
|
|
{ "PhysicalDeviceDriverProperties", StructureType::ePhysicalDeviceDriverProperties },
|
|
{ "PhysicalDeviceShaderAtomicInt64Features", StructureType::ePhysicalDeviceShaderAtomicInt64Features },
|
|
{ "PhysicalDeviceShaderFloat16Int8Features", StructureType::ePhysicalDeviceShaderFloat16Int8Features },
|
|
{ "PhysicalDeviceFloatControlsProperties", StructureType::ePhysicalDeviceFloatControlsProperties },
|
|
{ "DescriptorSetLayoutBindingFlagsCreateInfo", StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo },
|
|
{ "PhysicalDeviceDescriptorIndexingFeatures", StructureType::ePhysicalDeviceDescriptorIndexingFeatures },
|
|
{ "PhysicalDeviceDescriptorIndexingProperties", StructureType::ePhysicalDeviceDescriptorIndexingProperties },
|
|
{ "DescriptorSetVariableDescriptorCountAllocateInfo", StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo },
|
|
{ "DescriptorSetVariableDescriptorCountLayoutSupport", StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport },
|
|
{ "PhysicalDeviceDepthStencilResolveProperties", StructureType::ePhysicalDeviceDepthStencilResolveProperties },
|
|
{ "SubpassDescriptionDepthStencilResolve", StructureType::eSubpassDescriptionDepthStencilResolve },
|
|
{ "PhysicalDeviceScalarBlockLayoutFeatures", StructureType::ePhysicalDeviceScalarBlockLayoutFeatures },
|
|
{ "ImageStencilUsageCreateInfo", StructureType::eImageStencilUsageCreateInfo },
|
|
{ "PhysicalDeviceSamplerFilterMinmaxProperties", StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties },
|
|
{ "SamplerReductionModeCreateInfo", StructureType::eSamplerReductionModeCreateInfo },
|
|
{ "PhysicalDeviceVulkanMemoryModelFeatures", StructureType::ePhysicalDeviceVulkanMemoryModelFeatures },
|
|
{ "PhysicalDeviceImagelessFramebufferFeatures", StructureType::ePhysicalDeviceImagelessFramebufferFeatures },
|
|
{ "FramebufferAttachmentsCreateInfo", StructureType::eFramebufferAttachmentsCreateInfo },
|
|
{ "FramebufferAttachmentImageInfo", StructureType::eFramebufferAttachmentImageInfo },
|
|
{ "RenderPassAttachmentBeginInfo", StructureType::eRenderPassAttachmentBeginInfo },
|
|
{ "PhysicalDeviceUniformBufferStandardLayoutFeatures", StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures },
|
|
{ "PhysicalDeviceShaderSubgroupExtendedTypesFeatures", StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures },
|
|
{ "PhysicalDeviceSeparateDepthStencilLayoutsFeatures", StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures },
|
|
{ "AttachmentReferenceStencilLayout", StructureType::eAttachmentReferenceStencilLayout },
|
|
{ "AttachmentDescriptionStencilLayout", StructureType::eAttachmentDescriptionStencilLayout },
|
|
{ "PhysicalDeviceHostQueryResetFeatures", StructureType::ePhysicalDeviceHostQueryResetFeatures },
|
|
{ "PhysicalDeviceTimelineSemaphoreFeatures", StructureType::ePhysicalDeviceTimelineSemaphoreFeatures },
|
|
{ "PhysicalDeviceTimelineSemaphoreProperties", StructureType::ePhysicalDeviceTimelineSemaphoreProperties },
|
|
{ "SemaphoreTypeCreateInfo", StructureType::eSemaphoreTypeCreateInfo },
|
|
{ "TimelineSemaphoreSubmitInfo", StructureType::eTimelineSemaphoreSubmitInfo },
|
|
{ "SemaphoreWaitInfo", StructureType::eSemaphoreWaitInfo },
|
|
{ "SemaphoreSignalInfo", StructureType::eSemaphoreSignalInfo },
|
|
{ "PhysicalDeviceBufferDeviceAddressFeatures", StructureType::ePhysicalDeviceBufferDeviceAddressFeatures },
|
|
{ "BufferDeviceAddressInfo", StructureType::eBufferDeviceAddressInfo },
|
|
{ "BufferOpaqueCaptureAddressCreateInfo", StructureType::eBufferOpaqueCaptureAddressCreateInfo },
|
|
{ "MemoryOpaqueCaptureAddressAllocateInfo", StructureType::eMemoryOpaqueCaptureAddressAllocateInfo },
|
|
{ "DeviceMemoryOpaqueCaptureAddressInfo", StructureType::eDeviceMemoryOpaqueCaptureAddressInfo },
|
|
{ "PhysicalDeviceVulkan13Features", StructureType::ePhysicalDeviceVulkan13Features },
|
|
{ "PhysicalDeviceVulkan13Properties", StructureType::ePhysicalDeviceVulkan13Properties },
|
|
{ "PipelineCreationFeedbackCreateInfo", StructureType::ePipelineCreationFeedbackCreateInfo },
|
|
{ "PhysicalDeviceShaderTerminateInvocationFeatures", StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures },
|
|
{ "PhysicalDeviceToolProperties", StructureType::ePhysicalDeviceToolProperties },
|
|
{ "PhysicalDeviceShaderDemoteToHelperInvocationFeatures", StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures },
|
|
{ "PhysicalDevicePrivateDataFeatures", StructureType::ePhysicalDevicePrivateDataFeatures },
|
|
{ "DevicePrivateDataCreateInfo", StructureType::eDevicePrivateDataCreateInfo },
|
|
{ "PrivateDataSlotCreateInfo", StructureType::ePrivateDataSlotCreateInfo },
|
|
{ "PhysicalDevicePipelineCreationCacheControlFeatures", StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures },
|
|
{ "MemoryBarrier2", StructureType::eMemoryBarrier2 },
|
|
{ "BufferMemoryBarrier2", StructureType::eBufferMemoryBarrier2 },
|
|
{ "ImageMemoryBarrier2", StructureType::eImageMemoryBarrier2 },
|
|
{ "DependencyInfo", StructureType::eDependencyInfo },
|
|
{ "SubmitInfo2", StructureType::eSubmitInfo2 },
|
|
{ "SemaphoreSubmitInfo", StructureType::eSemaphoreSubmitInfo },
|
|
{ "CommandBufferSubmitInfo", StructureType::eCommandBufferSubmitInfo },
|
|
{ "PhysicalDeviceSynchronization2Features", StructureType::ePhysicalDeviceSynchronization2Features },
|
|
{ "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures },
|
|
{ "PhysicalDeviceImageRobustnessFeatures", StructureType::ePhysicalDeviceImageRobustnessFeatures },
|
|
{ "CopyBufferInfo2", StructureType::eCopyBufferInfo2 },
|
|
{ "CopyImageInfo2", StructureType::eCopyImageInfo2 },
|
|
{ "CopyBufferToImageInfo2", StructureType::eCopyBufferToImageInfo2 },
|
|
{ "CopyImageToBufferInfo2", StructureType::eCopyImageToBufferInfo2 },
|
|
{ "BlitImageInfo2", StructureType::eBlitImageInfo2 },
|
|
{ "ResolveImageInfo2", StructureType::eResolveImageInfo2 },
|
|
{ "BufferCopy2", StructureType::eBufferCopy2 },
|
|
{ "ImageCopy2", StructureType::eImageCopy2 },
|
|
{ "ImageBlit2", StructureType::eImageBlit2 },
|
|
{ "BufferImageCopy2", StructureType::eBufferImageCopy2 },
|
|
{ "ImageResolve2", StructureType::eImageResolve2 },
|
|
{ "PhysicalDeviceSubgroupSizeControlProperties", StructureType::ePhysicalDeviceSubgroupSizeControlProperties },
|
|
{ "PipelineShaderStageRequiredSubgroupSizeCreateInfo", StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo },
|
|
{ "PhysicalDeviceSubgroupSizeControlFeatures", StructureType::ePhysicalDeviceSubgroupSizeControlFeatures },
|
|
{ "PhysicalDeviceInlineUniformBlockFeatures", StructureType::ePhysicalDeviceInlineUniformBlockFeatures },
|
|
{ "PhysicalDeviceInlineUniformBlockProperties", StructureType::ePhysicalDeviceInlineUniformBlockProperties },
|
|
{ "WriteDescriptorSetInlineUniformBlock", StructureType::eWriteDescriptorSetInlineUniformBlock },
|
|
{ "DescriptorPoolInlineUniformBlockCreateInfo", StructureType::eDescriptorPoolInlineUniformBlockCreateInfo },
|
|
{ "PhysicalDeviceTextureCompressionAstcHdrFeatures", StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures },
|
|
{ "RenderingInfo", StructureType::eRenderingInfo },
|
|
{ "RenderingAttachmentInfo", StructureType::eRenderingAttachmentInfo },
|
|
{ "PipelineRenderingCreateInfo", StructureType::ePipelineRenderingCreateInfo },
|
|
{ "PhysicalDeviceDynamicRenderingFeatures", StructureType::ePhysicalDeviceDynamicRenderingFeatures },
|
|
{ "CommandBufferInheritanceRenderingInfo", StructureType::eCommandBufferInheritanceRenderingInfo },
|
|
{ "PhysicalDeviceShaderIntegerDotProductFeatures", StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures },
|
|
{ "PhysicalDeviceShaderIntegerDotProductProperties", StructureType::ePhysicalDeviceShaderIntegerDotProductProperties },
|
|
{ "PhysicalDeviceTexelBufferAlignmentProperties", StructureType::ePhysicalDeviceTexelBufferAlignmentProperties },
|
|
{ "FormatProperties3", StructureType::eFormatProperties3 },
|
|
{ "PhysicalDeviceMaintenance4Features", StructureType::ePhysicalDeviceMaintenance4Features },
|
|
{ "PhysicalDeviceMaintenance4Properties", StructureType::ePhysicalDeviceMaintenance4Properties },
|
|
{ "DeviceBufferMemoryRequirements", StructureType::eDeviceBufferMemoryRequirements },
|
|
{ "DeviceImageMemoryRequirements", StructureType::eDeviceImageMemoryRequirements },
|
|
{ "SwapchainCreateInfoKHR", StructureType::eSwapchainCreateInfoKHR },
|
|
{ "PresentInfoKHR", StructureType::ePresentInfoKHR },
|
|
{ "DeviceGroupPresentCapabilitiesKHR", StructureType::eDeviceGroupPresentCapabilitiesKHR },
|
|
{ "ImageSwapchainCreateInfoKHR", StructureType::eImageSwapchainCreateInfoKHR },
|
|
{ "BindImageMemorySwapchainInfoKHR", StructureType::eBindImageMemorySwapchainInfoKHR },
|
|
{ "AcquireNextImageInfoKHR", StructureType::eAcquireNextImageInfoKHR },
|
|
{ "DeviceGroupPresentInfoKHR", StructureType::eDeviceGroupPresentInfoKHR },
|
|
{ "DeviceGroupSwapchainCreateInfoKHR", StructureType::eDeviceGroupSwapchainCreateInfoKHR },
|
|
{ "DisplayModeCreateInfoKHR", StructureType::eDisplayModeCreateInfoKHR },
|
|
{ "DisplaySurfaceCreateInfoKHR", StructureType::eDisplaySurfaceCreateInfoKHR },
|
|
{ "DisplayPresentInfoKHR", StructureType::eDisplayPresentInfoKHR },
|
|
#if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
{ "XlibSurfaceCreateInfoKHR", StructureType::eXlibSurfaceCreateInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
#if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
{ "XcbSurfaceCreateInfoKHR", StructureType::eXcbSurfaceCreateInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
{ "WaylandSurfaceCreateInfoKHR", StructureType::eWaylandSurfaceCreateInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
{ "AndroidSurfaceCreateInfoKHR", StructureType::eAndroidSurfaceCreateInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
{ "Win32SurfaceCreateInfoKHR", StructureType::eWin32SurfaceCreateInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
{ "DebugReportCallbackCreateInfoEXT", StructureType::eDebugReportCallbackCreateInfoEXT },
|
|
{ "PipelineRasterizationStateRasterizationOrderAMD", StructureType::ePipelineRasterizationStateRasterizationOrderAMD },
|
|
{ "DebugMarkerObjectNameInfoEXT", StructureType::eDebugMarkerObjectNameInfoEXT },
|
|
{ "DebugMarkerObjectTagInfoEXT", StructureType::eDebugMarkerObjectTagInfoEXT },
|
|
{ "DebugMarkerMarkerInfoEXT", StructureType::eDebugMarkerMarkerInfoEXT },
|
|
{ "VideoProfileInfoKHR", StructureType::eVideoProfileInfoKHR },
|
|
{ "VideoCapabilitiesKHR", StructureType::eVideoCapabilitiesKHR },
|
|
{ "VideoPictureResourceInfoKHR", StructureType::eVideoPictureResourceInfoKHR },
|
|
{ "VideoSessionMemoryRequirementsKHR", StructureType::eVideoSessionMemoryRequirementsKHR },
|
|
{ "BindVideoSessionMemoryInfoKHR", StructureType::eBindVideoSessionMemoryInfoKHR },
|
|
{ "VideoSessionCreateInfoKHR", StructureType::eVideoSessionCreateInfoKHR },
|
|
{ "VideoSessionParametersCreateInfoKHR", StructureType::eVideoSessionParametersCreateInfoKHR },
|
|
{ "VideoSessionParametersUpdateInfoKHR", StructureType::eVideoSessionParametersUpdateInfoKHR },
|
|
{ "VideoBeginCodingInfoKHR", StructureType::eVideoBeginCodingInfoKHR },
|
|
{ "VideoEndCodingInfoKHR", StructureType::eVideoEndCodingInfoKHR },
|
|
{ "VideoCodingControlInfoKHR", StructureType::eVideoCodingControlInfoKHR },
|
|
{ "VideoReferenceSlotInfoKHR", StructureType::eVideoReferenceSlotInfoKHR },
|
|
{ "QueueFamilyVideoPropertiesKHR", StructureType::eQueueFamilyVideoPropertiesKHR },
|
|
{ "VideoProfileListInfoKHR", StructureType::eVideoProfileListInfoKHR },
|
|
{ "PhysicalDeviceVideoFormatInfoKHR", StructureType::ePhysicalDeviceVideoFormatInfoKHR },
|
|
{ "VideoFormatPropertiesKHR", StructureType::eVideoFormatPropertiesKHR },
|
|
{ "QueueFamilyQueryResultStatusPropertiesKHR", StructureType::eQueueFamilyQueryResultStatusPropertiesKHR },
|
|
{ "VideoDecodeInfoKHR", StructureType::eVideoDecodeInfoKHR },
|
|
{ "VideoDecodeCapabilitiesKHR", StructureType::eVideoDecodeCapabilitiesKHR },
|
|
{ "VideoDecodeUsageInfoKHR", StructureType::eVideoDecodeUsageInfoKHR },
|
|
{ "DedicatedAllocationImageCreateInfoNV", StructureType::eDedicatedAllocationImageCreateInfoNV },
|
|
{ "DedicatedAllocationBufferCreateInfoNV", StructureType::eDedicatedAllocationBufferCreateInfoNV },
|
|
{ "DedicatedAllocationMemoryAllocateInfoNV", StructureType::eDedicatedAllocationMemoryAllocateInfoNV },
|
|
{ "PhysicalDeviceTransformFeedbackFeaturesEXT", StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT },
|
|
{ "PhysicalDeviceTransformFeedbackPropertiesEXT", StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT },
|
|
{ "PipelineRasterizationStateStreamCreateInfoEXT", StructureType::ePipelineRasterizationStateStreamCreateInfoEXT },
|
|
{ "CuModuleCreateInfoNVX", StructureType::eCuModuleCreateInfoNVX },
|
|
{ "CuFunctionCreateInfoNVX", StructureType::eCuFunctionCreateInfoNVX },
|
|
{ "CuLaunchInfoNVX", StructureType::eCuLaunchInfoNVX },
|
|
{ "ImageViewHandleInfoNVX", StructureType::eImageViewHandleInfoNVX },
|
|
{ "ImageViewAddressPropertiesNVX", StructureType::eImageViewAddressPropertiesNVX },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeH264CapabilitiesEXT", StructureType::eVideoEncodeH264CapabilitiesEXT },
|
|
{ "VideoEncodeH264SessionParametersCreateInfoEXT", StructureType::eVideoEncodeH264SessionParametersCreateInfoEXT },
|
|
{ "VideoEncodeH264SessionParametersAddInfoEXT", StructureType::eVideoEncodeH264SessionParametersAddInfoEXT },
|
|
{ "VideoEncodeH264PictureInfoEXT", StructureType::eVideoEncodeH264PictureInfoEXT },
|
|
{ "VideoEncodeH264DpbSlotInfoEXT", StructureType::eVideoEncodeH264DpbSlotInfoEXT },
|
|
{ "VideoEncodeH264NaluSliceInfoEXT", StructureType::eVideoEncodeH264NaluSliceInfoEXT },
|
|
{ "VideoEncodeH264GopRemainingFrameInfoEXT", StructureType::eVideoEncodeH264GopRemainingFrameInfoEXT },
|
|
{ "VideoEncodeH264ProfileInfoEXT", StructureType::eVideoEncodeH264ProfileInfoEXT },
|
|
{ "VideoEncodeH264RateControlInfoEXT", StructureType::eVideoEncodeH264RateControlInfoEXT },
|
|
{ "VideoEncodeH264RateControlLayerInfoEXT", StructureType::eVideoEncodeH264RateControlLayerInfoEXT },
|
|
{ "VideoEncodeH264SessionCreateInfoEXT", StructureType::eVideoEncodeH264SessionCreateInfoEXT },
|
|
{ "VideoEncodeH264QualityLevelPropertiesEXT", StructureType::eVideoEncodeH264QualityLevelPropertiesEXT },
|
|
{ "VideoEncodeH264SessionParametersGetInfoEXT", StructureType::eVideoEncodeH264SessionParametersGetInfoEXT },
|
|
{ "VideoEncodeH264SessionParametersFeedbackInfoEXT", StructureType::eVideoEncodeH264SessionParametersFeedbackInfoEXT },
|
|
{ "VideoEncodeH265CapabilitiesEXT", StructureType::eVideoEncodeH265CapabilitiesEXT },
|
|
{ "VideoEncodeH265SessionParametersCreateInfoEXT", StructureType::eVideoEncodeH265SessionParametersCreateInfoEXT },
|
|
{ "VideoEncodeH265SessionParametersAddInfoEXT", StructureType::eVideoEncodeH265SessionParametersAddInfoEXT },
|
|
{ "VideoEncodeH265PictureInfoEXT", StructureType::eVideoEncodeH265PictureInfoEXT },
|
|
{ "VideoEncodeH265DpbSlotInfoEXT", StructureType::eVideoEncodeH265DpbSlotInfoEXT },
|
|
{ "VideoEncodeH265NaluSliceSegmentInfoEXT", StructureType::eVideoEncodeH265NaluSliceSegmentInfoEXT },
|
|
{ "VideoEncodeH265GopRemainingFrameInfoEXT", StructureType::eVideoEncodeH265GopRemainingFrameInfoEXT },
|
|
{ "VideoEncodeH265ProfileInfoEXT", StructureType::eVideoEncodeH265ProfileInfoEXT },
|
|
{ "VideoEncodeH265RateControlInfoEXT", StructureType::eVideoEncodeH265RateControlInfoEXT },
|
|
{ "VideoEncodeH265RateControlLayerInfoEXT", StructureType::eVideoEncodeH265RateControlLayerInfoEXT },
|
|
{ "VideoEncodeH265SessionCreateInfoEXT", StructureType::eVideoEncodeH265SessionCreateInfoEXT },
|
|
{ "VideoEncodeH265QualityLevelPropertiesEXT", StructureType::eVideoEncodeH265QualityLevelPropertiesEXT },
|
|
{ "VideoEncodeH265SessionParametersGetInfoEXT", StructureType::eVideoEncodeH265SessionParametersGetInfoEXT },
|
|
{ "VideoEncodeH265SessionParametersFeedbackInfoEXT", StructureType::eVideoEncodeH265SessionParametersFeedbackInfoEXT },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "VideoDecodeH264CapabilitiesKHR", StructureType::eVideoDecodeH264CapabilitiesKHR },
|
|
{ "VideoDecodeH264PictureInfoKHR", StructureType::eVideoDecodeH264PictureInfoKHR },
|
|
{ "VideoDecodeH264ProfileInfoKHR", StructureType::eVideoDecodeH264ProfileInfoKHR },
|
|
{ "VideoDecodeH264SessionParametersCreateInfoKHR", StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR },
|
|
{ "VideoDecodeH264SessionParametersAddInfoKHR", StructureType::eVideoDecodeH264SessionParametersAddInfoKHR },
|
|
{ "VideoDecodeH264DpbSlotInfoKHR", StructureType::eVideoDecodeH264DpbSlotInfoKHR },
|
|
{ "TextureLodGatherFormatPropertiesAMD", StructureType::eTextureLodGatherFormatPropertiesAMD },
|
|
{ "RenderingFragmentShadingRateAttachmentInfoKHR", StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR },
|
|
{ "RenderingFragmentDensityMapAttachmentInfoEXT", StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT },
|
|
{ "AttachmentSampleCountInfoAMD", StructureType::eAttachmentSampleCountInfoAMD },
|
|
{ "MultiviewPerViewAttributesInfoNVX", StructureType::eMultiviewPerViewAttributesInfoNVX },
|
|
#if defined( VK_USE_PLATFORM_GGP )
|
|
{ "StreamDescriptorSurfaceCreateInfoGGP", StructureType::eStreamDescriptorSurfaceCreateInfoGGP },
|
|
#endif /*VK_USE_PLATFORM_GGP*/
|
|
{ "PhysicalDeviceCornerSampledImageFeaturesNV", StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV },
|
|
{ "ExternalMemoryImageCreateInfoNV", StructureType::eExternalMemoryImageCreateInfoNV },
|
|
{ "ExportMemoryAllocateInfoNV", StructureType::eExportMemoryAllocateInfoNV },
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
{ "ImportMemoryWin32HandleInfoNV", StructureType::eImportMemoryWin32HandleInfoNV },
|
|
{ "ExportMemoryWin32HandleInfoNV", StructureType::eExportMemoryWin32HandleInfoNV },
|
|
{ "Win32KeyedMutexAcquireReleaseInfoNV", StructureType::eWin32KeyedMutexAcquireReleaseInfoNV },
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
{ "ValidationFlagsEXT", StructureType::eValidationFlagsEXT },
|
|
#if defined( VK_USE_PLATFORM_VI_NN )
|
|
{ "ViSurfaceCreateInfoNN", StructureType::eViSurfaceCreateInfoNN },
|
|
#endif /*VK_USE_PLATFORM_VI_NN*/
|
|
{ "ImageViewAstcDecodeModeEXT", StructureType::eImageViewAstcDecodeModeEXT },
|
|
{ "PhysicalDeviceAstcDecodeFeaturesEXT", StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT },
|
|
{ "PipelineRobustnessCreateInfoEXT", StructureType::ePipelineRobustnessCreateInfoEXT },
|
|
{ "PhysicalDevicePipelineRobustnessFeaturesEXT", StructureType::ePhysicalDevicePipelineRobustnessFeaturesEXT },
|
|
{ "PhysicalDevicePipelineRobustnessPropertiesEXT", StructureType::ePhysicalDevicePipelineRobustnessPropertiesEXT },
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
{ "ImportMemoryWin32HandleInfoKHR", StructureType::eImportMemoryWin32HandleInfoKHR },
|
|
{ "ExportMemoryWin32HandleInfoKHR", StructureType::eExportMemoryWin32HandleInfoKHR },
|
|
{ "MemoryWin32HandlePropertiesKHR", StructureType::eMemoryWin32HandlePropertiesKHR },
|
|
{ "MemoryGetWin32HandleInfoKHR", StructureType::eMemoryGetWin32HandleInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
{ "ImportMemoryFdInfoKHR", StructureType::eImportMemoryFdInfoKHR },
|
|
{ "MemoryFdPropertiesKHR", StructureType::eMemoryFdPropertiesKHR },
|
|
{ "MemoryGetFdInfoKHR", StructureType::eMemoryGetFdInfoKHR },
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
{ "Win32KeyedMutexAcquireReleaseInfoKHR", StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR },
|
|
{ "ImportSemaphoreWin32HandleInfoKHR", StructureType::eImportSemaphoreWin32HandleInfoKHR },
|
|
{ "ExportSemaphoreWin32HandleInfoKHR", StructureType::eExportSemaphoreWin32HandleInfoKHR },
|
|
{ "D3D12FenceSubmitInfoKHR", StructureType::eD3D12FenceSubmitInfoKHR },
|
|
{ "SemaphoreGetWin32HandleInfoKHR", StructureType::eSemaphoreGetWin32HandleInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
{ "ImportSemaphoreFdInfoKHR", StructureType::eImportSemaphoreFdInfoKHR },
|
|
{ "SemaphoreGetFdInfoKHR", StructureType::eSemaphoreGetFdInfoKHR },
|
|
{ "PhysicalDevicePushDescriptorPropertiesKHR", StructureType::ePhysicalDevicePushDescriptorPropertiesKHR },
|
|
{ "CommandBufferInheritanceConditionalRenderingInfoEXT", StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT },
|
|
{ "PhysicalDeviceConditionalRenderingFeaturesEXT", StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT },
|
|
{ "ConditionalRenderingBeginInfoEXT", StructureType::eConditionalRenderingBeginInfoEXT },
|
|
{ "PresentRegionsKHR", StructureType::ePresentRegionsKHR },
|
|
{ "PipelineViewportWScalingStateCreateInfoNV", StructureType::ePipelineViewportWScalingStateCreateInfoNV },
|
|
{ "SurfaceCapabilities2EXT", StructureType::eSurfaceCapabilities2EXT },
|
|
{ "DisplayPowerInfoEXT", StructureType::eDisplayPowerInfoEXT },
|
|
{ "DeviceEventInfoEXT", StructureType::eDeviceEventInfoEXT },
|
|
{ "DisplayEventInfoEXT", StructureType::eDisplayEventInfoEXT },
|
|
{ "SwapchainCounterCreateInfoEXT", StructureType::eSwapchainCounterCreateInfoEXT },
|
|
{ "PresentTimesInfoGOOGLE", StructureType::ePresentTimesInfoGOOGLE },
|
|
{ "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX", StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX },
|
|
{ "PipelineViewportSwizzleStateCreateInfoNV", StructureType::ePipelineViewportSwizzleStateCreateInfoNV },
|
|
{ "PhysicalDeviceDiscardRectanglePropertiesEXT", StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT },
|
|
{ "PipelineDiscardRectangleStateCreateInfoEXT", StructureType::ePipelineDiscardRectangleStateCreateInfoEXT },
|
|
{ "PhysicalDeviceConservativeRasterizationPropertiesEXT", StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT },
|
|
{ "PipelineRasterizationConservativeStateCreateInfoEXT", StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT },
|
|
{ "PhysicalDeviceDepthClipEnableFeaturesEXT", StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT },
|
|
{ "PipelineRasterizationDepthClipStateCreateInfoEXT", StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT },
|
|
{ "HdrMetadataEXT", StructureType::eHdrMetadataEXT },
|
|
{ "PhysicalDeviceRelaxedLineRasterizationFeaturesIMG", StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG },
|
|
{ "SharedPresentSurfaceCapabilitiesKHR", StructureType::eSharedPresentSurfaceCapabilitiesKHR },
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
{ "ImportFenceWin32HandleInfoKHR", StructureType::eImportFenceWin32HandleInfoKHR },
|
|
{ "ExportFenceWin32HandleInfoKHR", StructureType::eExportFenceWin32HandleInfoKHR },
|
|
{ "FenceGetWin32HandleInfoKHR", StructureType::eFenceGetWin32HandleInfoKHR },
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
{ "ImportFenceFdInfoKHR", StructureType::eImportFenceFdInfoKHR },
|
|
{ "FenceGetFdInfoKHR", StructureType::eFenceGetFdInfoKHR },
|
|
{ "PhysicalDevicePerformanceQueryFeaturesKHR", StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR },
|
|
{ "PhysicalDevicePerformanceQueryPropertiesKHR", StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR },
|
|
{ "QueryPoolPerformanceCreateInfoKHR", StructureType::eQueryPoolPerformanceCreateInfoKHR },
|
|
{ "PerformanceQuerySubmitInfoKHR", StructureType::ePerformanceQuerySubmitInfoKHR },
|
|
{ "AcquireProfilingLockInfoKHR", StructureType::eAcquireProfilingLockInfoKHR },
|
|
{ "PerformanceCounterKHR", StructureType::ePerformanceCounterKHR },
|
|
{ "PerformanceCounterDescriptionKHR", StructureType::ePerformanceCounterDescriptionKHR },
|
|
{ "PhysicalDeviceSurfaceInfo2KHR", StructureType::ePhysicalDeviceSurfaceInfo2KHR },
|
|
{ "SurfaceCapabilities2KHR", StructureType::eSurfaceCapabilities2KHR },
|
|
{ "SurfaceFormat2KHR", StructureType::eSurfaceFormat2KHR },
|
|
{ "DisplayProperties2KHR", StructureType::eDisplayProperties2KHR },
|
|
{ "DisplayPlaneProperties2KHR", StructureType::eDisplayPlaneProperties2KHR },
|
|
{ "DisplayModeProperties2KHR", StructureType::eDisplayModeProperties2KHR },
|
|
{ "DisplayPlaneInfo2KHR", StructureType::eDisplayPlaneInfo2KHR },
|
|
{ "DisplayPlaneCapabilities2KHR", StructureType::eDisplayPlaneCapabilities2KHR },
|
|
#if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
{ "IosSurfaceCreateInfoMVK", StructureType::eIosSurfaceCreateInfoMVK },
|
|
#endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
#if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
{ "MacosSurfaceCreateInfoMVK", StructureType::eMacosSurfaceCreateInfoMVK },
|
|
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
{ "DebugUtilsObjectNameInfoEXT", StructureType::eDebugUtilsObjectNameInfoEXT },
|
|
{ "DebugUtilsObjectTagInfoEXT", StructureType::eDebugUtilsObjectTagInfoEXT },
|
|
{ "DebugUtilsLabelEXT", StructureType::eDebugUtilsLabelEXT },
|
|
{ "DebugUtilsMessengerCallbackDataEXT", StructureType::eDebugUtilsMessengerCallbackDataEXT },
|
|
{ "DebugUtilsMessengerCreateInfoEXT", StructureType::eDebugUtilsMessengerCreateInfoEXT },
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
{ "AndroidHardwareBufferUsageANDROID", StructureType::eAndroidHardwareBufferUsageANDROID },
|
|
{ "AndroidHardwareBufferPropertiesANDROID", StructureType::eAndroidHardwareBufferPropertiesANDROID },
|
|
{ "AndroidHardwareBufferFormatPropertiesANDROID", StructureType::eAndroidHardwareBufferFormatPropertiesANDROID },
|
|
{ "ImportAndroidHardwareBufferInfoANDROID", StructureType::eImportAndroidHardwareBufferInfoANDROID },
|
|
{ "MemoryGetAndroidHardwareBufferInfoANDROID", StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID },
|
|
{ "ExternalFormatANDROID", StructureType::eExternalFormatANDROID },
|
|
{ "AndroidHardwareBufferFormatProperties2ANDROID", StructureType::eAndroidHardwareBufferFormatProperties2ANDROID },
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "PhysicalDeviceShaderEnqueueFeaturesAMDX", StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX },
|
|
{ "PhysicalDeviceShaderEnqueuePropertiesAMDX", StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX },
|
|
{ "ExecutionGraphPipelineScratchSizeAMDX", StructureType::eExecutionGraphPipelineScratchSizeAMDX },
|
|
{ "ExecutionGraphPipelineCreateInfoAMDX", StructureType::eExecutionGraphPipelineCreateInfoAMDX },
|
|
{ "PipelineShaderStageNodeCreateInfoAMDX", StructureType::ePipelineShaderStageNodeCreateInfoAMDX },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "SampleLocationsInfoEXT", StructureType::eSampleLocationsInfoEXT },
|
|
{ "RenderPassSampleLocationsBeginInfoEXT", StructureType::eRenderPassSampleLocationsBeginInfoEXT },
|
|
{ "PipelineSampleLocationsStateCreateInfoEXT", StructureType::ePipelineSampleLocationsStateCreateInfoEXT },
|
|
{ "PhysicalDeviceSampleLocationsPropertiesEXT", StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT },
|
|
{ "MultisamplePropertiesEXT", StructureType::eMultisamplePropertiesEXT },
|
|
{ "PhysicalDeviceBlendOperationAdvancedFeaturesEXT", StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT },
|
|
{ "PhysicalDeviceBlendOperationAdvancedPropertiesEXT", StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT },
|
|
{ "PipelineColorBlendAdvancedStateCreateInfoEXT", StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT },
|
|
{ "PipelineCoverageToColorStateCreateInfoNV", StructureType::ePipelineCoverageToColorStateCreateInfoNV },
|
|
{ "WriteDescriptorSetAccelerationStructureKHR", StructureType::eWriteDescriptorSetAccelerationStructureKHR },
|
|
{ "AccelerationStructureBuildGeometryInfoKHR", StructureType::eAccelerationStructureBuildGeometryInfoKHR },
|
|
{ "AccelerationStructureDeviceAddressInfoKHR", StructureType::eAccelerationStructureDeviceAddressInfoKHR },
|
|
{ "AccelerationStructureGeometryAabbsDataKHR", StructureType::eAccelerationStructureGeometryAabbsDataKHR },
|
|
{ "AccelerationStructureGeometryInstancesDataKHR", StructureType::eAccelerationStructureGeometryInstancesDataKHR },
|
|
{ "AccelerationStructureGeometryTrianglesDataKHR", StructureType::eAccelerationStructureGeometryTrianglesDataKHR },
|
|
{ "AccelerationStructureGeometryKHR", StructureType::eAccelerationStructureGeometryKHR },
|
|
{ "AccelerationStructureVersionInfoKHR", StructureType::eAccelerationStructureVersionInfoKHR },
|
|
{ "CopyAccelerationStructureInfoKHR", StructureType::eCopyAccelerationStructureInfoKHR },
|
|
{ "CopyAccelerationStructureToMemoryInfoKHR", StructureType::eCopyAccelerationStructureToMemoryInfoKHR },
|
|
{ "CopyMemoryToAccelerationStructureInfoKHR", StructureType::eCopyMemoryToAccelerationStructureInfoKHR },
|
|
{ "PhysicalDeviceAccelerationStructureFeaturesKHR", StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR },
|
|
{ "PhysicalDeviceAccelerationStructurePropertiesKHR", StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR },
|
|
{ "AccelerationStructureCreateInfoKHR", StructureType::eAccelerationStructureCreateInfoKHR },
|
|
{ "AccelerationStructureBuildSizesInfoKHR", StructureType::eAccelerationStructureBuildSizesInfoKHR },
|
|
{ "PhysicalDeviceRayTracingPipelineFeaturesKHR", StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR },
|
|
{ "PhysicalDeviceRayTracingPipelinePropertiesKHR", StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR },
|
|
{ "RayTracingPipelineCreateInfoKHR", StructureType::eRayTracingPipelineCreateInfoKHR },
|
|
{ "RayTracingShaderGroupCreateInfoKHR", StructureType::eRayTracingShaderGroupCreateInfoKHR },
|
|
{ "RayTracingPipelineInterfaceCreateInfoKHR", StructureType::eRayTracingPipelineInterfaceCreateInfoKHR },
|
|
{ "PhysicalDeviceRayQueryFeaturesKHR", StructureType::ePhysicalDeviceRayQueryFeaturesKHR },
|
|
{ "PipelineCoverageModulationStateCreateInfoNV", StructureType::ePipelineCoverageModulationStateCreateInfoNV },
|
|
{ "PhysicalDeviceShaderSmBuiltinsFeaturesNV", StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV },
|
|
{ "PhysicalDeviceShaderSmBuiltinsPropertiesNV", StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV },
|
|
{ "DrmFormatModifierPropertiesListEXT", StructureType::eDrmFormatModifierPropertiesListEXT },
|
|
{ "PhysicalDeviceImageDrmFormatModifierInfoEXT", StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT },
|
|
{ "ImageDrmFormatModifierListCreateInfoEXT", StructureType::eImageDrmFormatModifierListCreateInfoEXT },
|
|
{ "ImageDrmFormatModifierExplicitCreateInfoEXT", StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT },
|
|
{ "ImageDrmFormatModifierPropertiesEXT", StructureType::eImageDrmFormatModifierPropertiesEXT },
|
|
{ "DrmFormatModifierPropertiesList2EXT", StructureType::eDrmFormatModifierPropertiesList2EXT },
|
|
{ "ValidationCacheCreateInfoEXT", StructureType::eValidationCacheCreateInfoEXT },
|
|
{ "ShaderModuleValidationCacheCreateInfoEXT", StructureType::eShaderModuleValidationCacheCreateInfoEXT },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "PhysicalDevicePortabilitySubsetFeaturesKHR", StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR },
|
|
{ "PhysicalDevicePortabilitySubsetPropertiesKHR", StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "PipelineViewportShadingRateImageStateCreateInfoNV", StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV },
|
|
{ "PhysicalDeviceShadingRateImageFeaturesNV", StructureType::ePhysicalDeviceShadingRateImageFeaturesNV },
|
|
{ "PhysicalDeviceShadingRateImagePropertiesNV", StructureType::ePhysicalDeviceShadingRateImagePropertiesNV },
|
|
{ "PipelineViewportCoarseSampleOrderStateCreateInfoNV", StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV },
|
|
{ "RayTracingPipelineCreateInfoNV", StructureType::eRayTracingPipelineCreateInfoNV },
|
|
{ "AccelerationStructureCreateInfoNV", StructureType::eAccelerationStructureCreateInfoNV },
|
|
{ "GeometryNV", StructureType::eGeometryNV },
|
|
{ "GeometryTrianglesNV", StructureType::eGeometryTrianglesNV },
|
|
{ "GeometryAabbNV", StructureType::eGeometryAabbNV },
|
|
{ "BindAccelerationStructureMemoryInfoNV", StructureType::eBindAccelerationStructureMemoryInfoNV },
|
|
{ "WriteDescriptorSetAccelerationStructureNV", StructureType::eWriteDescriptorSetAccelerationStructureNV },
|
|
{ "AccelerationStructureMemoryRequirementsInfoNV", StructureType::eAccelerationStructureMemoryRequirementsInfoNV },
|
|
{ "PhysicalDeviceRayTracingPropertiesNV", StructureType::ePhysicalDeviceRayTracingPropertiesNV },
|
|
{ "RayTracingShaderGroupCreateInfoNV", StructureType::eRayTracingShaderGroupCreateInfoNV },
|
|
{ "AccelerationStructureInfoNV", StructureType::eAccelerationStructureInfoNV },
|
|
{ "PhysicalDeviceRepresentativeFragmentTestFeaturesNV", StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV },
|
|
{ "PipelineRepresentativeFragmentTestStateCreateInfoNV", StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV },
|
|
{ "PhysicalDeviceImageViewImageFormatInfoEXT", StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT },
|
|
{ "FilterCubicImageViewImageFormatPropertiesEXT", StructureType::eFilterCubicImageViewImageFormatPropertiesEXT },
|
|
{ "ImportMemoryHostPointerInfoEXT", StructureType::eImportMemoryHostPointerInfoEXT },
|
|
{ "MemoryHostPointerPropertiesEXT", StructureType::eMemoryHostPointerPropertiesEXT },
|
|
{ "PhysicalDeviceExternalMemoryHostPropertiesEXT", StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT },
|
|
{ "PhysicalDeviceShaderClockFeaturesKHR", StructureType::ePhysicalDeviceShaderClockFeaturesKHR },
|
|
{ "PipelineCompilerControlCreateInfoAMD", StructureType::ePipelineCompilerControlCreateInfoAMD },
|
|
{ "CalibratedTimestampInfoEXT", StructureType::eCalibratedTimestampInfoEXT },
|
|
{ "PhysicalDeviceShaderCorePropertiesAMD", StructureType::ePhysicalDeviceShaderCorePropertiesAMD },
|
|
{ "VideoDecodeH265CapabilitiesKHR", StructureType::eVideoDecodeH265CapabilitiesKHR },
|
|
{ "VideoDecodeH265SessionParametersCreateInfoKHR", StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR },
|
|
{ "VideoDecodeH265SessionParametersAddInfoKHR", StructureType::eVideoDecodeH265SessionParametersAddInfoKHR },
|
|
{ "VideoDecodeH265ProfileInfoKHR", StructureType::eVideoDecodeH265ProfileInfoKHR },
|
|
{ "VideoDecodeH265PictureInfoKHR", StructureType::eVideoDecodeH265PictureInfoKHR },
|
|
{ "VideoDecodeH265DpbSlotInfoKHR", StructureType::eVideoDecodeH265DpbSlotInfoKHR },
|
|
{ "DeviceQueueGlobalPriorityCreateInfoKHR", StructureType::eDeviceQueueGlobalPriorityCreateInfoKHR },
|
|
{ "PhysicalDeviceGlobalPriorityQueryFeaturesKHR", StructureType::ePhysicalDeviceGlobalPriorityQueryFeaturesKHR },
|
|
{ "QueueFamilyGlobalPriorityPropertiesKHR", StructureType::eQueueFamilyGlobalPriorityPropertiesKHR },
|
|
{ "DeviceMemoryOverallocationCreateInfoAMD", StructureType::eDeviceMemoryOverallocationCreateInfoAMD },
|
|
{ "PhysicalDeviceVertexAttributeDivisorPropertiesEXT", StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT },
|
|
{ "PipelineVertexInputDivisorStateCreateInfoEXT", StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT },
|
|
{ "PhysicalDeviceVertexAttributeDivisorFeaturesEXT", StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT },
|
|
#if defined( VK_USE_PLATFORM_GGP )
|
|
{ "PresentFrameTokenGGP", StructureType::ePresentFrameTokenGGP },
|
|
#endif /*VK_USE_PLATFORM_GGP*/
|
|
{ "PhysicalDeviceComputeShaderDerivativesFeaturesNV", StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV },
|
|
{ "PhysicalDeviceMeshShaderFeaturesNV", StructureType::ePhysicalDeviceMeshShaderFeaturesNV },
|
|
{ "PhysicalDeviceMeshShaderPropertiesNV", StructureType::ePhysicalDeviceMeshShaderPropertiesNV },
|
|
{ "PhysicalDeviceShaderImageFootprintFeaturesNV", StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV },
|
|
{ "PipelineViewportExclusiveScissorStateCreateInfoNV", StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV },
|
|
{ "PhysicalDeviceExclusiveScissorFeaturesNV", StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV },
|
|
{ "CheckpointDataNV", StructureType::eCheckpointDataNV },
|
|
{ "QueueFamilyCheckpointPropertiesNV", StructureType::eQueueFamilyCheckpointPropertiesNV },
|
|
{ "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL", StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL },
|
|
{ "QueryPoolPerformanceQueryCreateInfoINTEL", StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL },
|
|
{ "InitializePerformanceApiInfoINTEL", StructureType::eInitializePerformanceApiInfoINTEL },
|
|
{ "PerformanceMarkerInfoINTEL", StructureType::ePerformanceMarkerInfoINTEL },
|
|
{ "PerformanceStreamMarkerInfoINTEL", StructureType::ePerformanceStreamMarkerInfoINTEL },
|
|
{ "PerformanceOverrideInfoINTEL", StructureType::ePerformanceOverrideInfoINTEL },
|
|
{ "PerformanceConfigurationAcquireInfoINTEL", StructureType::ePerformanceConfigurationAcquireInfoINTEL },
|
|
{ "PhysicalDevicePciBusInfoPropertiesEXT", StructureType::ePhysicalDevicePciBusInfoPropertiesEXT },
|
|
{ "DisplayNativeHdrSurfaceCapabilitiesAMD", StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD },
|
|
{ "SwapchainDisplayNativeHdrCreateInfoAMD", StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD },
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
{ "ImagepipeSurfaceCreateInfoFUCHSIA", StructureType::eImagepipeSurfaceCreateInfoFUCHSIA },
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
{ "MetalSurfaceCreateInfoEXT", StructureType::eMetalSurfaceCreateInfoEXT },
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
{ "PhysicalDeviceFragmentDensityMapFeaturesEXT", StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT },
|
|
{ "PhysicalDeviceFragmentDensityMapPropertiesEXT", StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT },
|
|
{ "RenderPassFragmentDensityMapCreateInfoEXT", StructureType::eRenderPassFragmentDensityMapCreateInfoEXT },
|
|
{ "FragmentShadingRateAttachmentInfoKHR", StructureType::eFragmentShadingRateAttachmentInfoKHR },
|
|
{ "PipelineFragmentShadingRateStateCreateInfoKHR", StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR },
|
|
{ "PhysicalDeviceFragmentShadingRatePropertiesKHR", StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR },
|
|
{ "PhysicalDeviceFragmentShadingRateFeaturesKHR", StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR },
|
|
{ "PhysicalDeviceFragmentShadingRateKHR", StructureType::ePhysicalDeviceFragmentShadingRateKHR },
|
|
{ "PhysicalDeviceShaderCoreProperties2AMD", StructureType::ePhysicalDeviceShaderCoreProperties2AMD },
|
|
{ "PhysicalDeviceCoherentMemoryFeaturesAMD", StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD },
|
|
{ "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT", StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT },
|
|
{ "PhysicalDeviceMemoryBudgetPropertiesEXT", StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT },
|
|
{ "PhysicalDeviceMemoryPriorityFeaturesEXT", StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT },
|
|
{ "MemoryPriorityAllocateInfoEXT", StructureType::eMemoryPriorityAllocateInfoEXT },
|
|
{ "SurfaceProtectedCapabilitiesKHR", StructureType::eSurfaceProtectedCapabilitiesKHR },
|
|
{ "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV", StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV },
|
|
{ "PhysicalDeviceBufferDeviceAddressFeaturesEXT", StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT },
|
|
{ "BufferDeviceAddressCreateInfoEXT", StructureType::eBufferDeviceAddressCreateInfoEXT },
|
|
{ "ValidationFeaturesEXT", StructureType::eValidationFeaturesEXT },
|
|
{ "PhysicalDevicePresentWaitFeaturesKHR", StructureType::ePhysicalDevicePresentWaitFeaturesKHR },
|
|
{ "PhysicalDeviceCooperativeMatrixFeaturesNV", StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV },
|
|
{ "CooperativeMatrixPropertiesNV", StructureType::eCooperativeMatrixPropertiesNV },
|
|
{ "PhysicalDeviceCooperativeMatrixPropertiesNV", StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV },
|
|
{ "PhysicalDeviceCoverageReductionModeFeaturesNV", StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV },
|
|
{ "PipelineCoverageReductionStateCreateInfoNV", StructureType::ePipelineCoverageReductionStateCreateInfoNV },
|
|
{ "FramebufferMixedSamplesCombinationNV", StructureType::eFramebufferMixedSamplesCombinationNV },
|
|
{ "PhysicalDeviceFragmentShaderInterlockFeaturesEXT", StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT },
|
|
{ "PhysicalDeviceYcbcrImageArraysFeaturesEXT", StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT },
|
|
{ "PhysicalDeviceProvokingVertexFeaturesEXT", StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT },
|
|
{ "PipelineRasterizationProvokingVertexStateCreateInfoEXT", StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT },
|
|
{ "PhysicalDeviceProvokingVertexPropertiesEXT", StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT },
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
{ "SurfaceFullScreenExclusiveInfoEXT", StructureType::eSurfaceFullScreenExclusiveInfoEXT },
|
|
{ "SurfaceCapabilitiesFullScreenExclusiveEXT", StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT },
|
|
{ "SurfaceFullScreenExclusiveWin32InfoEXT", StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT },
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
{ "HeadlessSurfaceCreateInfoEXT", StructureType::eHeadlessSurfaceCreateInfoEXT },
|
|
{ "PhysicalDeviceLineRasterizationFeaturesEXT", StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT },
|
|
{ "PipelineRasterizationLineStateCreateInfoEXT", StructureType::ePipelineRasterizationLineStateCreateInfoEXT },
|
|
{ "PhysicalDeviceLineRasterizationPropertiesEXT", StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT },
|
|
{ "PhysicalDeviceShaderAtomicFloatFeaturesEXT", StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT },
|
|
{ "PhysicalDeviceIndexTypeUint8FeaturesEXT", StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT },
|
|
{ "PhysicalDeviceExtendedDynamicStateFeaturesEXT", StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT },
|
|
{ "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR", StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR },
|
|
{ "PipelineInfoKHR", StructureType::ePipelineInfoKHR },
|
|
{ "PipelineExecutablePropertiesKHR", StructureType::ePipelineExecutablePropertiesKHR },
|
|
{ "PipelineExecutableInfoKHR", StructureType::ePipelineExecutableInfoKHR },
|
|
{ "PipelineExecutableStatisticKHR", StructureType::ePipelineExecutableStatisticKHR },
|
|
{ "PipelineExecutableInternalRepresentationKHR", StructureType::ePipelineExecutableInternalRepresentationKHR },
|
|
{ "PhysicalDeviceHostImageCopyFeaturesEXT", StructureType::ePhysicalDeviceHostImageCopyFeaturesEXT },
|
|
{ "PhysicalDeviceHostImageCopyPropertiesEXT", StructureType::ePhysicalDeviceHostImageCopyPropertiesEXT },
|
|
{ "MemoryToImageCopyEXT", StructureType::eMemoryToImageCopyEXT },
|
|
{ "ImageToMemoryCopyEXT", StructureType::eImageToMemoryCopyEXT },
|
|
{ "CopyImageToMemoryInfoEXT", StructureType::eCopyImageToMemoryInfoEXT },
|
|
{ "CopyMemoryToImageInfoEXT", StructureType::eCopyMemoryToImageInfoEXT },
|
|
{ "HostImageLayoutTransitionInfoEXT", StructureType::eHostImageLayoutTransitionInfoEXT },
|
|
{ "CopyImageToImageInfoEXT", StructureType::eCopyImageToImageInfoEXT },
|
|
{ "SubresourceHostMemcpySizeEXT", StructureType::eSubresourceHostMemcpySizeEXT },
|
|
{ "HostImageCopyDevicePerformanceQueryEXT", StructureType::eHostImageCopyDevicePerformanceQueryEXT },
|
|
{ "MemoryMapInfoKHR", StructureType::eMemoryMapInfoKHR },
|
|
{ "MemoryUnmapInfoKHR", StructureType::eMemoryUnmapInfoKHR },
|
|
{ "PhysicalDeviceShaderAtomicFloat2FeaturesEXT", StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT },
|
|
{ "SurfacePresentModeEXT", StructureType::eSurfacePresentModeEXT },
|
|
{ "SurfacePresentScalingCapabilitiesEXT", StructureType::eSurfacePresentScalingCapabilitiesEXT },
|
|
{ "SurfacePresentModeCompatibilityEXT", StructureType::eSurfacePresentModeCompatibilityEXT },
|
|
{ "PhysicalDeviceSwapchainMaintenance1FeaturesEXT", StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesEXT },
|
|
{ "SwapchainPresentFenceInfoEXT", StructureType::eSwapchainPresentFenceInfoEXT },
|
|
{ "SwapchainPresentModesCreateInfoEXT", StructureType::eSwapchainPresentModesCreateInfoEXT },
|
|
{ "SwapchainPresentModeInfoEXT", StructureType::eSwapchainPresentModeInfoEXT },
|
|
{ "SwapchainPresentScalingCreateInfoEXT", StructureType::eSwapchainPresentScalingCreateInfoEXT },
|
|
{ "ReleaseSwapchainImagesInfoEXT", StructureType::eReleaseSwapchainImagesInfoEXT },
|
|
{ "PhysicalDeviceDeviceGeneratedCommandsPropertiesNV", StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV },
|
|
{ "GraphicsShaderGroupCreateInfoNV", StructureType::eGraphicsShaderGroupCreateInfoNV },
|
|
{ "GraphicsPipelineShaderGroupsCreateInfoNV", StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV },
|
|
{ "IndirectCommandsLayoutTokenNV", StructureType::eIndirectCommandsLayoutTokenNV },
|
|
{ "IndirectCommandsLayoutCreateInfoNV", StructureType::eIndirectCommandsLayoutCreateInfoNV },
|
|
{ "GeneratedCommandsInfoNV", StructureType::eGeneratedCommandsInfoNV },
|
|
{ "GeneratedCommandsMemoryRequirementsInfoNV", StructureType::eGeneratedCommandsMemoryRequirementsInfoNV },
|
|
{ "PhysicalDeviceDeviceGeneratedCommandsFeaturesNV", StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV },
|
|
{ "PhysicalDeviceInheritedViewportScissorFeaturesNV", StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV },
|
|
{ "CommandBufferInheritanceViewportScissorInfoNV", StructureType::eCommandBufferInheritanceViewportScissorInfoNV },
|
|
{ "PhysicalDeviceTexelBufferAlignmentFeaturesEXT", StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT },
|
|
{ "CommandBufferInheritanceRenderPassTransformInfoQCOM", StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM },
|
|
{ "RenderPassTransformBeginInfoQCOM", StructureType::eRenderPassTransformBeginInfoQCOM },
|
|
{ "PhysicalDeviceDepthBiasControlFeaturesEXT", StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT },
|
|
{ "DepthBiasInfoEXT", StructureType::eDepthBiasInfoEXT },
|
|
{ "DepthBiasRepresentationInfoEXT", StructureType::eDepthBiasRepresentationInfoEXT },
|
|
{ "PhysicalDeviceDeviceMemoryReportFeaturesEXT", StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT },
|
|
{ "DeviceDeviceMemoryReportCreateInfoEXT", StructureType::eDeviceDeviceMemoryReportCreateInfoEXT },
|
|
{ "DeviceMemoryReportCallbackDataEXT", StructureType::eDeviceMemoryReportCallbackDataEXT },
|
|
{ "PhysicalDeviceRobustness2FeaturesEXT", StructureType::ePhysicalDeviceRobustness2FeaturesEXT },
|
|
{ "PhysicalDeviceRobustness2PropertiesEXT", StructureType::ePhysicalDeviceRobustness2PropertiesEXT },
|
|
{ "SamplerCustomBorderColorCreateInfoEXT", StructureType::eSamplerCustomBorderColorCreateInfoEXT },
|
|
{ "PhysicalDeviceCustomBorderColorPropertiesEXT", StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT },
|
|
{ "PhysicalDeviceCustomBorderColorFeaturesEXT", StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT },
|
|
{ "PipelineLibraryCreateInfoKHR", StructureType::ePipelineLibraryCreateInfoKHR },
|
|
{ "PhysicalDevicePresentBarrierFeaturesNV", StructureType::ePhysicalDevicePresentBarrierFeaturesNV },
|
|
{ "SurfaceCapabilitiesPresentBarrierNV", StructureType::eSurfaceCapabilitiesPresentBarrierNV },
|
|
{ "SwapchainPresentBarrierCreateInfoNV", StructureType::eSwapchainPresentBarrierCreateInfoNV },
|
|
{ "PresentIdKHR", StructureType::ePresentIdKHR },
|
|
{ "PhysicalDevicePresentIdFeaturesKHR", StructureType::ePhysicalDevicePresentIdFeaturesKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeInfoKHR", StructureType::eVideoEncodeInfoKHR },
|
|
{ "VideoEncodeRateControlInfoKHR", StructureType::eVideoEncodeRateControlInfoKHR },
|
|
{ "VideoEncodeRateControlLayerInfoKHR", StructureType::eVideoEncodeRateControlLayerInfoKHR },
|
|
{ "VideoEncodeCapabilitiesKHR", StructureType::eVideoEncodeCapabilitiesKHR },
|
|
{ "VideoEncodeUsageInfoKHR", StructureType::eVideoEncodeUsageInfoKHR },
|
|
{ "QueryPoolVideoEncodeFeedbackCreateInfoKHR", StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR },
|
|
{ "PhysicalDeviceVideoEncodeQualityLevelInfoKHR", StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR },
|
|
{ "VideoEncodeQualityLevelPropertiesKHR", StructureType::eVideoEncodeQualityLevelPropertiesKHR },
|
|
{ "VideoEncodeQualityLevelInfoKHR", StructureType::eVideoEncodeQualityLevelInfoKHR },
|
|
{ "VideoEncodeSessionParametersGetInfoKHR", StructureType::eVideoEncodeSessionParametersGetInfoKHR },
|
|
{ "VideoEncodeSessionParametersFeedbackInfoKHR", StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "PhysicalDeviceDiagnosticsConfigFeaturesNV", StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV },
|
|
{ "DeviceDiagnosticsConfigCreateInfoNV", StructureType::eDeviceDiagnosticsConfigCreateInfoNV },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "CudaModuleCreateInfoNV", StructureType::eCudaModuleCreateInfoNV },
|
|
{ "CudaFunctionCreateInfoNV", StructureType::eCudaFunctionCreateInfoNV },
|
|
{ "CudaLaunchInfoNV", StructureType::eCudaLaunchInfoNV },
|
|
{ "PhysicalDeviceCudaKernelLaunchFeaturesNV", StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV },
|
|
{ "PhysicalDeviceCudaKernelLaunchPropertiesNV", StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "QueryLowLatencySupportNV", StructureType::eQueryLowLatencySupportNV },
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
{ "ExportMetalObjectCreateInfoEXT", StructureType::eExportMetalObjectCreateInfoEXT },
|
|
{ "ExportMetalObjectsInfoEXT", StructureType::eExportMetalObjectsInfoEXT },
|
|
{ "ExportMetalDeviceInfoEXT", StructureType::eExportMetalDeviceInfoEXT },
|
|
{ "ExportMetalCommandQueueInfoEXT", StructureType::eExportMetalCommandQueueInfoEXT },
|
|
{ "ExportMetalBufferInfoEXT", StructureType::eExportMetalBufferInfoEXT },
|
|
{ "ImportMetalBufferInfoEXT", StructureType::eImportMetalBufferInfoEXT },
|
|
{ "ExportMetalTextureInfoEXT", StructureType::eExportMetalTextureInfoEXT },
|
|
{ "ImportMetalTextureInfoEXT", StructureType::eImportMetalTextureInfoEXT },
|
|
{ "ExportMetalIoSurfaceInfoEXT", StructureType::eExportMetalIoSurfaceInfoEXT },
|
|
{ "ImportMetalIoSurfaceInfoEXT", StructureType::eImportMetalIoSurfaceInfoEXT },
|
|
{ "ExportMetalSharedEventInfoEXT", StructureType::eExportMetalSharedEventInfoEXT },
|
|
{ "ImportMetalSharedEventInfoEXT", StructureType::eImportMetalSharedEventInfoEXT },
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
{ "QueueFamilyCheckpointProperties2NV", StructureType::eQueueFamilyCheckpointProperties2NV },
|
|
{ "CheckpointData2NV", StructureType::eCheckpointData2NV },
|
|
{ "PhysicalDeviceDescriptorBufferPropertiesEXT", StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT },
|
|
{ "PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT", StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT },
|
|
{ "PhysicalDeviceDescriptorBufferFeaturesEXT", StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT },
|
|
{ "DescriptorAddressInfoEXT", StructureType::eDescriptorAddressInfoEXT },
|
|
{ "DescriptorGetInfoEXT", StructureType::eDescriptorGetInfoEXT },
|
|
{ "BufferCaptureDescriptorDataInfoEXT", StructureType::eBufferCaptureDescriptorDataInfoEXT },
|
|
{ "ImageCaptureDescriptorDataInfoEXT", StructureType::eImageCaptureDescriptorDataInfoEXT },
|
|
{ "ImageViewCaptureDescriptorDataInfoEXT", StructureType::eImageViewCaptureDescriptorDataInfoEXT },
|
|
{ "SamplerCaptureDescriptorDataInfoEXT", StructureType::eSamplerCaptureDescriptorDataInfoEXT },
|
|
{ "OpaqueCaptureDescriptorDataCreateInfoEXT", StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT },
|
|
{ "DescriptorBufferBindingInfoEXT", StructureType::eDescriptorBufferBindingInfoEXT },
|
|
{ "DescriptorBufferBindingPushDescriptorBufferHandleEXT", StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT },
|
|
{ "AccelerationStructureCaptureDescriptorDataInfoEXT", StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT },
|
|
{ "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT", StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT },
|
|
{ "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT", StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT },
|
|
{ "GraphicsPipelineLibraryCreateInfoEXT", StructureType::eGraphicsPipelineLibraryCreateInfoEXT },
|
|
{ "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD", StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD },
|
|
{ "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR", StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR },
|
|
{ "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR", StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR },
|
|
{ "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR", StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR },
|
|
{ "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV", StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV },
|
|
{ "PhysicalDeviceFragmentShadingRateEnumsFeaturesNV", StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV },
|
|
{ "PipelineFragmentShadingRateEnumStateCreateInfoNV", StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV },
|
|
{ "AccelerationStructureGeometryMotionTrianglesDataNV", StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV },
|
|
{ "PhysicalDeviceRayTracingMotionBlurFeaturesNV", StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV },
|
|
{ "AccelerationStructureMotionInfoNV", StructureType::eAccelerationStructureMotionInfoNV },
|
|
{ "PhysicalDeviceMeshShaderFeaturesEXT", StructureType::ePhysicalDeviceMeshShaderFeaturesEXT },
|
|
{ "PhysicalDeviceMeshShaderPropertiesEXT", StructureType::ePhysicalDeviceMeshShaderPropertiesEXT },
|
|
{ "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT },
|
|
{ "PhysicalDeviceFragmentDensityMap2FeaturesEXT", StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT },
|
|
{ "PhysicalDeviceFragmentDensityMap2PropertiesEXT", StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT },
|
|
{ "CopyCommandTransformInfoQCOM", StructureType::eCopyCommandTransformInfoQCOM },
|
|
{ "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR", StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR },
|
|
{ "PhysicalDeviceImageCompressionControlFeaturesEXT", StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT },
|
|
{ "ImageCompressionControlEXT", StructureType::eImageCompressionControlEXT },
|
|
{ "ImageCompressionPropertiesEXT", StructureType::eImageCompressionPropertiesEXT },
|
|
{ "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT", StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT },
|
|
{ "PhysicalDevice4444FormatsFeaturesEXT", StructureType::ePhysicalDevice4444FormatsFeaturesEXT },
|
|
{ "PhysicalDeviceFaultFeaturesEXT", StructureType::ePhysicalDeviceFaultFeaturesEXT },
|
|
{ "DeviceFaultCountsEXT", StructureType::eDeviceFaultCountsEXT },
|
|
{ "DeviceFaultInfoEXT", StructureType::eDeviceFaultInfoEXT },
|
|
{ "PhysicalDeviceRgba10X6FormatsFeaturesEXT", StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT },
|
|
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
{ "DirectfbSurfaceCreateInfoEXT", StructureType::eDirectfbSurfaceCreateInfoEXT },
|
|
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
{ "PhysicalDeviceVertexInputDynamicStateFeaturesEXT", StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT },
|
|
{ "VertexInputBindingDescription2EXT", StructureType::eVertexInputBindingDescription2EXT },
|
|
{ "VertexInputAttributeDescription2EXT", StructureType::eVertexInputAttributeDescription2EXT },
|
|
{ "PhysicalDeviceDrmPropertiesEXT", StructureType::ePhysicalDeviceDrmPropertiesEXT },
|
|
{ "PhysicalDeviceAddressBindingReportFeaturesEXT", StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT },
|
|
{ "DeviceAddressBindingCallbackDataEXT", StructureType::eDeviceAddressBindingCallbackDataEXT },
|
|
{ "PhysicalDeviceDepthClipControlFeaturesEXT", StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT },
|
|
{ "PipelineViewportDepthClipControlCreateInfoEXT", StructureType::ePipelineViewportDepthClipControlCreateInfoEXT },
|
|
{ "PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT", StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT },
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
{ "ImportMemoryZirconHandleInfoFUCHSIA", StructureType::eImportMemoryZirconHandleInfoFUCHSIA },
|
|
{ "MemoryZirconHandlePropertiesFUCHSIA", StructureType::eMemoryZirconHandlePropertiesFUCHSIA },
|
|
{ "MemoryGetZirconHandleInfoFUCHSIA", StructureType::eMemoryGetZirconHandleInfoFUCHSIA },
|
|
{ "ImportSemaphoreZirconHandleInfoFUCHSIA", StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA },
|
|
{ "SemaphoreGetZirconHandleInfoFUCHSIA", StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA },
|
|
{ "BufferCollectionCreateInfoFUCHSIA", StructureType::eBufferCollectionCreateInfoFUCHSIA },
|
|
{ "ImportMemoryBufferCollectionFUCHSIA", StructureType::eImportMemoryBufferCollectionFUCHSIA },
|
|
{ "BufferCollectionImageCreateInfoFUCHSIA", StructureType::eBufferCollectionImageCreateInfoFUCHSIA },
|
|
{ "BufferCollectionPropertiesFUCHSIA", StructureType::eBufferCollectionPropertiesFUCHSIA },
|
|
{ "BufferConstraintsInfoFUCHSIA", StructureType::eBufferConstraintsInfoFUCHSIA },
|
|
{ "BufferCollectionBufferCreateInfoFUCHSIA", StructureType::eBufferCollectionBufferCreateInfoFUCHSIA },
|
|
{ "ImageConstraintsInfoFUCHSIA", StructureType::eImageConstraintsInfoFUCHSIA },
|
|
{ "ImageFormatConstraintsInfoFUCHSIA", StructureType::eImageFormatConstraintsInfoFUCHSIA },
|
|
{ "SysmemColorSpaceFUCHSIA", StructureType::eSysmemColorSpaceFUCHSIA },
|
|
{ "BufferCollectionConstraintsInfoFUCHSIA", StructureType::eBufferCollectionConstraintsInfoFUCHSIA },
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
{ "SubpassShadingPipelineCreateInfoHUAWEI", StructureType::eSubpassShadingPipelineCreateInfoHUAWEI },
|
|
{ "PhysicalDeviceSubpassShadingFeaturesHUAWEI", StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI },
|
|
{ "PhysicalDeviceSubpassShadingPropertiesHUAWEI", StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI },
|
|
{ "PhysicalDeviceInvocationMaskFeaturesHUAWEI", StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI },
|
|
{ "MemoryGetRemoteAddressInfoNV", StructureType::eMemoryGetRemoteAddressInfoNV },
|
|
{ "PhysicalDeviceExternalMemoryRdmaFeaturesNV", StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV },
|
|
{ "PipelinePropertiesIdentifierEXT", StructureType::ePipelinePropertiesIdentifierEXT },
|
|
{ "PhysicalDevicePipelinePropertiesFeaturesEXT", StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT },
|
|
{ "PhysicalDeviceFrameBoundaryFeaturesEXT", StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT },
|
|
{ "FrameBoundaryEXT", StructureType::eFrameBoundaryEXT },
|
|
{ "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT", StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT },
|
|
{ "SubpassResolvePerformanceQueryEXT", StructureType::eSubpassResolvePerformanceQueryEXT },
|
|
{ "MultisampledRenderToSingleSampledInfoEXT", StructureType::eMultisampledRenderToSingleSampledInfoEXT },
|
|
{ "PhysicalDeviceExtendedDynamicState2FeaturesEXT", StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT },
|
|
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
{ "ScreenSurfaceCreateInfoQNX", StructureType::eScreenSurfaceCreateInfoQNX },
|
|
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
{ "PhysicalDeviceColorWriteEnableFeaturesEXT", StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT },
|
|
{ "PipelineColorWriteCreateInfoEXT", StructureType::ePipelineColorWriteCreateInfoEXT },
|
|
{ "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT", StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT },
|
|
{ "PhysicalDeviceRayTracingMaintenance1FeaturesKHR", StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR },
|
|
{ "PhysicalDeviceImageViewMinLodFeaturesEXT", StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT },
|
|
{ "ImageViewMinLodCreateInfoEXT", StructureType::eImageViewMinLodCreateInfoEXT },
|
|
{ "PhysicalDeviceMultiDrawFeaturesEXT", StructureType::ePhysicalDeviceMultiDrawFeaturesEXT },
|
|
{ "PhysicalDeviceMultiDrawPropertiesEXT", StructureType::ePhysicalDeviceMultiDrawPropertiesEXT },
|
|
{ "PhysicalDeviceImage2DViewOf3DFeaturesEXT", StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT },
|
|
{ "PhysicalDeviceShaderTileImageFeaturesEXT", StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT },
|
|
{ "PhysicalDeviceShaderTileImagePropertiesEXT", StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT },
|
|
{ "MicromapBuildInfoEXT", StructureType::eMicromapBuildInfoEXT },
|
|
{ "MicromapVersionInfoEXT", StructureType::eMicromapVersionInfoEXT },
|
|
{ "CopyMicromapInfoEXT", StructureType::eCopyMicromapInfoEXT },
|
|
{ "CopyMicromapToMemoryInfoEXT", StructureType::eCopyMicromapToMemoryInfoEXT },
|
|
{ "CopyMemoryToMicromapInfoEXT", StructureType::eCopyMemoryToMicromapInfoEXT },
|
|
{ "PhysicalDeviceOpacityMicromapFeaturesEXT", StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT },
|
|
{ "PhysicalDeviceOpacityMicromapPropertiesEXT", StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT },
|
|
{ "MicromapCreateInfoEXT", StructureType::eMicromapCreateInfoEXT },
|
|
{ "MicromapBuildSizesInfoEXT", StructureType::eMicromapBuildSizesInfoEXT },
|
|
{ "AccelerationStructureTrianglesOpacityMicromapEXT", StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "PhysicalDeviceDisplacementMicromapFeaturesNV", StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV },
|
|
{ "PhysicalDeviceDisplacementMicromapPropertiesNV", StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV },
|
|
{ "AccelerationStructureTrianglesDisplacementMicromapNV", StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "PhysicalDeviceClusterCullingShaderFeaturesHUAWEI", StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI },
|
|
{ "PhysicalDeviceClusterCullingShaderPropertiesHUAWEI", StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI },
|
|
{ "PhysicalDeviceBorderColorSwizzleFeaturesEXT", StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT },
|
|
{ "SamplerBorderColorComponentMappingCreateInfoEXT", StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT },
|
|
{ "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT", StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT },
|
|
{ "PhysicalDeviceShaderCorePropertiesARM", StructureType::ePhysicalDeviceShaderCorePropertiesARM },
|
|
{ "DeviceQueueShaderCoreControlCreateInfoARM", StructureType::eDeviceQueueShaderCoreControlCreateInfoARM },
|
|
{ "PhysicalDeviceSchedulingControlsFeaturesARM", StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM },
|
|
{ "PhysicalDeviceSchedulingControlsPropertiesARM", StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM },
|
|
{ "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT", StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT },
|
|
{ "ImageViewSlicedCreateInfoEXT", StructureType::eImageViewSlicedCreateInfoEXT },
|
|
{ "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE", StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE },
|
|
{ "DescriptorSetBindingReferenceVALVE", StructureType::eDescriptorSetBindingReferenceVALVE },
|
|
{ "DescriptorSetLayoutHostMappingInfoVALVE", StructureType::eDescriptorSetLayoutHostMappingInfoVALVE },
|
|
{ "PhysicalDeviceDepthClampZeroOneFeaturesEXT", StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT },
|
|
{ "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT", StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT },
|
|
{ "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM", StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM },
|
|
{ "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM", StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM },
|
|
{ "SubpassFragmentDensityMapOffsetEndInfoQCOM", StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM },
|
|
{ "PhysicalDeviceCopyMemoryIndirectFeaturesNV", StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV },
|
|
{ "PhysicalDeviceCopyMemoryIndirectPropertiesNV", StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesNV },
|
|
{ "PhysicalDeviceMemoryDecompressionFeaturesNV", StructureType::ePhysicalDeviceMemoryDecompressionFeaturesNV },
|
|
{ "PhysicalDeviceMemoryDecompressionPropertiesNV", StructureType::ePhysicalDeviceMemoryDecompressionPropertiesNV },
|
|
{ "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV", StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV },
|
|
{ "ComputePipelineIndirectBufferInfoNV", StructureType::eComputePipelineIndirectBufferInfoNV },
|
|
{ "PipelineIndirectDeviceAddressInfoNV", StructureType::ePipelineIndirectDeviceAddressInfoNV },
|
|
{ "PhysicalDeviceLinearColorAttachmentFeaturesNV", StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV },
|
|
{ "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT", StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT },
|
|
{ "PhysicalDeviceImageProcessingFeaturesQCOM", StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM },
|
|
{ "PhysicalDeviceImageProcessingPropertiesQCOM", StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM },
|
|
{ "ImageViewSampleWeightCreateInfoQCOM", StructureType::eImageViewSampleWeightCreateInfoQCOM },
|
|
{ "PhysicalDeviceNestedCommandBufferFeaturesEXT", StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT },
|
|
{ "PhysicalDeviceNestedCommandBufferPropertiesEXT", StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT },
|
|
{ "ExternalMemoryAcquireUnmodifiedEXT", StructureType::eExternalMemoryAcquireUnmodifiedEXT },
|
|
{ "PhysicalDeviceExtendedDynamicState3FeaturesEXT", StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT },
|
|
{ "PhysicalDeviceExtendedDynamicState3PropertiesEXT", StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT },
|
|
{ "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT", StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT },
|
|
{ "RenderPassCreationControlEXT", StructureType::eRenderPassCreationControlEXT },
|
|
{ "RenderPassCreationFeedbackCreateInfoEXT", StructureType::eRenderPassCreationFeedbackCreateInfoEXT },
|
|
{ "RenderPassSubpassFeedbackCreateInfoEXT", StructureType::eRenderPassSubpassFeedbackCreateInfoEXT },
|
|
{ "DirectDriverLoadingInfoLUNARG", StructureType::eDirectDriverLoadingInfoLUNARG },
|
|
{ "DirectDriverLoadingListLUNARG", StructureType::eDirectDriverLoadingListLUNARG },
|
|
{ "PhysicalDeviceShaderModuleIdentifierFeaturesEXT", StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT },
|
|
{ "PhysicalDeviceShaderModuleIdentifierPropertiesEXT", StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT },
|
|
{ "PipelineShaderStageModuleIdentifierCreateInfoEXT", StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT },
|
|
{ "ShaderModuleIdentifierEXT", StructureType::eShaderModuleIdentifierEXT },
|
|
{ "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT", StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT },
|
|
{ "PhysicalDeviceOpticalFlowFeaturesNV", StructureType::ePhysicalDeviceOpticalFlowFeaturesNV },
|
|
{ "PhysicalDeviceOpticalFlowPropertiesNV", StructureType::ePhysicalDeviceOpticalFlowPropertiesNV },
|
|
{ "OpticalFlowImageFormatInfoNV", StructureType::eOpticalFlowImageFormatInfoNV },
|
|
{ "OpticalFlowImageFormatPropertiesNV", StructureType::eOpticalFlowImageFormatPropertiesNV },
|
|
{ "OpticalFlowSessionCreateInfoNV", StructureType::eOpticalFlowSessionCreateInfoNV },
|
|
{ "OpticalFlowExecuteInfoNV", StructureType::eOpticalFlowExecuteInfoNV },
|
|
{ "OpticalFlowSessionCreatePrivateDataInfoNV", StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV },
|
|
{ "PhysicalDeviceLegacyDitheringFeaturesEXT", StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT },
|
|
{ "PhysicalDevicePipelineProtectedAccessFeaturesEXT", StructureType::ePhysicalDevicePipelineProtectedAccessFeaturesEXT },
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
{ "PhysicalDeviceExternalFormatResolveFeaturesANDROID", StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID },
|
|
{ "PhysicalDeviceExternalFormatResolvePropertiesANDROID", StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID },
|
|
{ "AndroidHardwareBufferFormatResolvePropertiesANDROID", StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID },
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
{ "PhysicalDeviceMaintenance5FeaturesKHR", StructureType::ePhysicalDeviceMaintenance5FeaturesKHR },
|
|
{ "PhysicalDeviceMaintenance5PropertiesKHR", StructureType::ePhysicalDeviceMaintenance5PropertiesKHR },
|
|
{ "RenderingAreaInfoKHR", StructureType::eRenderingAreaInfoKHR },
|
|
{ "DeviceImageSubresourceInfoKHR", StructureType::eDeviceImageSubresourceInfoKHR },
|
|
{ "SubresourceLayout2KHR", StructureType::eSubresourceLayout2KHR },
|
|
{ "ImageSubresource2KHR", StructureType::eImageSubresource2KHR },
|
|
{ "PipelineCreateFlags2CreateInfoKHR", StructureType::ePipelineCreateFlags2CreateInfoKHR },
|
|
{ "BufferUsageFlags2CreateInfoKHR", StructureType::eBufferUsageFlags2CreateInfoKHR },
|
|
{ "PhysicalDeviceRayTracingPositionFetchFeaturesKHR", StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR },
|
|
{ "PhysicalDeviceShaderObjectFeaturesEXT", StructureType::ePhysicalDeviceShaderObjectFeaturesEXT },
|
|
{ "PhysicalDeviceShaderObjectPropertiesEXT", StructureType::ePhysicalDeviceShaderObjectPropertiesEXT },
|
|
{ "ShaderCreateInfoEXT", StructureType::eShaderCreateInfoEXT },
|
|
{ "PhysicalDeviceTilePropertiesFeaturesQCOM", StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM },
|
|
{ "TilePropertiesQCOM", StructureType::eTilePropertiesQCOM },
|
|
{ "PhysicalDeviceAmigoProfilingFeaturesSEC", StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC },
|
|
{ "AmigoProfilingSubmitInfoSEC", StructureType::eAmigoProfilingSubmitInfoSEC },
|
|
{ "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM", StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM },
|
|
{ "PhysicalDeviceRayTracingInvocationReorderFeaturesNV", StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV },
|
|
{ "PhysicalDeviceRayTracingInvocationReorderPropertiesNV", StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV },
|
|
{ "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV", StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV },
|
|
{ "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV", StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV },
|
|
{ "PhysicalDeviceMutableDescriptorTypeFeaturesEXT", StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT },
|
|
{ "MutableDescriptorTypeCreateInfoEXT", StructureType::eMutableDescriptorTypeCreateInfoEXT },
|
|
{ "PhysicalDeviceShaderCoreBuiltinsFeaturesARM", StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM },
|
|
{ "PhysicalDeviceShaderCoreBuiltinsPropertiesARM", StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM },
|
|
{ "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT", StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT },
|
|
{ "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT", StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT },
|
|
{ "LatencySleepModeInfoNV", StructureType::eLatencySleepModeInfoNV },
|
|
{ "LatencySleepInfoNV", StructureType::eLatencySleepInfoNV },
|
|
{ "SetLatencyMarkerInfoNV", StructureType::eSetLatencyMarkerInfoNV },
|
|
{ "GetLatencyMarkerInfoNV", StructureType::eGetLatencyMarkerInfoNV },
|
|
{ "LatencyTimingsFrameReportNV", StructureType::eLatencyTimingsFrameReportNV },
|
|
{ "LatencySubmissionPresentIdNV", StructureType::eLatencySubmissionPresentIdNV },
|
|
{ "OutOfBandQueueTypeInfoNV", StructureType::eOutOfBandQueueTypeInfoNV },
|
|
{ "SwapchainLatencyCreateInfoNV", StructureType::eSwapchainLatencyCreateInfoNV },
|
|
{ "LatencySurfaceCapabilitiesNV", StructureType::eLatencySurfaceCapabilitiesNV },
|
|
{ "PhysicalDeviceCooperativeMatrixFeaturesKHR", StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR },
|
|
{ "CooperativeMatrixPropertiesKHR", StructureType::eCooperativeMatrixPropertiesKHR },
|
|
{ "PhysicalDeviceCooperativeMatrixPropertiesKHR", StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR },
|
|
{ "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM", StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM },
|
|
{ "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM", StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM },
|
|
{ "PhysicalDeviceImageProcessing2FeaturesQCOM", StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM },
|
|
{ "PhysicalDeviceImageProcessing2PropertiesQCOM", StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM },
|
|
{ "SamplerBlockMatchWindowCreateInfoQCOM", StructureType::eSamplerBlockMatchWindowCreateInfoQCOM },
|
|
{ "SamplerCubicWeightsCreateInfoQCOM", StructureType::eSamplerCubicWeightsCreateInfoQCOM },
|
|
{ "PhysicalDeviceCubicWeightsFeaturesQCOM", StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM },
|
|
{ "BlitImageCubicWeightsInfoQCOM", StructureType::eBlitImageCubicWeightsInfoQCOM },
|
|
{ "PhysicalDeviceYcbcrDegammaFeaturesQCOM", StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM },
|
|
{ "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM", StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM },
|
|
{ "PhysicalDeviceCubicClampFeaturesQCOM", StructureType::ePhysicalDeviceCubicClampFeaturesQCOM },
|
|
{ "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT", StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT },
|
|
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
{ "ScreenBufferPropertiesQNX", StructureType::eScreenBufferPropertiesQNX },
|
|
{ "ScreenBufferFormatPropertiesQNX", StructureType::eScreenBufferFormatPropertiesQNX },
|
|
{ "ImportScreenBufferInfoQNX", StructureType::eImportScreenBufferInfoQNX },
|
|
{ "ExternalFormatQNX", StructureType::eExternalFormatQNX },
|
|
{ "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX", StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX },
|
|
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
{ "PhysicalDeviceLayeredDriverPropertiesMSFT", StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT },
|
|
{ "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV", StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCacheHeaderVersion> PipelineCacheHeaderVersionEntries = {
|
|
{ "One", PipelineCacheHeaderVersion::eOne },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ObjectType> ObjectTypeEntries = {
|
|
{ "Unknown", ObjectType::eUnknown },
|
|
{ "Instance", ObjectType::eInstance },
|
|
{ "PhysicalDevice", ObjectType::ePhysicalDevice },
|
|
{ "Device", ObjectType::eDevice },
|
|
{ "Queue", ObjectType::eQueue },
|
|
{ "Semaphore", ObjectType::eSemaphore },
|
|
{ "CommandBuffer", ObjectType::eCommandBuffer },
|
|
{ "Fence", ObjectType::eFence },
|
|
{ "DeviceMemory", ObjectType::eDeviceMemory },
|
|
{ "Buffer", ObjectType::eBuffer },
|
|
{ "Image", ObjectType::eImage },
|
|
{ "Event", ObjectType::eEvent },
|
|
{ "QueryPool", ObjectType::eQueryPool },
|
|
{ "BufferView", ObjectType::eBufferView },
|
|
{ "ImageView", ObjectType::eImageView },
|
|
{ "ShaderModule", ObjectType::eShaderModule },
|
|
{ "PipelineCache", ObjectType::ePipelineCache },
|
|
{ "PipelineLayout", ObjectType::ePipelineLayout },
|
|
{ "RenderPass", ObjectType::eRenderPass },
|
|
{ "Pipeline", ObjectType::ePipeline },
|
|
{ "DescriptorSetLayout", ObjectType::eDescriptorSetLayout },
|
|
{ "Sampler", ObjectType::eSampler },
|
|
{ "DescriptorPool", ObjectType::eDescriptorPool },
|
|
{ "DescriptorSet", ObjectType::eDescriptorSet },
|
|
{ "Framebuffer", ObjectType::eFramebuffer },
|
|
{ "CommandPool", ObjectType::eCommandPool },
|
|
{ "SamplerYcbcrConversion", ObjectType::eSamplerYcbcrConversion },
|
|
{ "DescriptorUpdateTemplate", ObjectType::eDescriptorUpdateTemplate },
|
|
{ "PrivateDataSlot", ObjectType::ePrivateDataSlot },
|
|
{ "SurfaceKHR", ObjectType::eSurfaceKHR },
|
|
{ "SwapchainKHR", ObjectType::eSwapchainKHR },
|
|
{ "DisplayKHR", ObjectType::eDisplayKHR },
|
|
{ "DisplayModeKHR", ObjectType::eDisplayModeKHR },
|
|
{ "DebugReportCallbackEXT", ObjectType::eDebugReportCallbackEXT },
|
|
{ "VideoSessionKHR", ObjectType::eVideoSessionKHR },
|
|
{ "VideoSessionParametersKHR", ObjectType::eVideoSessionParametersKHR },
|
|
{ "CuModuleNVX", ObjectType::eCuModuleNVX },
|
|
{ "CuFunctionNVX", ObjectType::eCuFunctionNVX },
|
|
{ "DebugUtilsMessengerEXT", ObjectType::eDebugUtilsMessengerEXT },
|
|
{ "AccelerationStructureKHR", ObjectType::eAccelerationStructureKHR },
|
|
{ "ValidationCacheEXT", ObjectType::eValidationCacheEXT },
|
|
{ "AccelerationStructureNV", ObjectType::eAccelerationStructureNV },
|
|
{ "PerformanceConfigurationINTEL", ObjectType::ePerformanceConfigurationINTEL },
|
|
{ "DeferredOperationKHR", ObjectType::eDeferredOperationKHR },
|
|
{ "IndirectCommandsLayoutNV", ObjectType::eIndirectCommandsLayoutNV },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "CudaModuleNV", ObjectType::eCudaModuleNV },
|
|
{ "CudaFunctionNV", ObjectType::eCudaFunctionNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
{ "BufferCollectionFUCHSIA", ObjectType::eBufferCollectionFUCHSIA },
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
{ "MicromapEXT", ObjectType::eMicromapEXT },
|
|
{ "OpticalFlowSessionNV", ObjectType::eOpticalFlowSessionNV },
|
|
{ "ShaderEXT", ObjectType::eShaderEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VendorId> VendorIdEntries = {
|
|
{ "VIV", VendorId::eVIV }, { "VSI", VendorId::eVSI }, { "Kazan", VendorId::eKazan }, { "Codeplay", VendorId::eCodeplay },
|
|
{ "MESA", VendorId::eMESA }, { "Pocl", VendorId::ePocl }, { "Mobileye", VendorId::eMobileye },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, Format> FormatEntries = {
|
|
{ "Undefined", Format::eUndefined },
|
|
{ "R4G4UnormPack8", Format::eR4G4UnormPack8 },
|
|
{ "R4G4B4A4UnormPack16", Format::eR4G4B4A4UnormPack16 },
|
|
{ "B4G4R4A4UnormPack16", Format::eB4G4R4A4UnormPack16 },
|
|
{ "R5G6B5UnormPack16", Format::eR5G6B5UnormPack16 },
|
|
{ "B5G6R5UnormPack16", Format::eB5G6R5UnormPack16 },
|
|
{ "R5G5B5A1UnormPack16", Format::eR5G5B5A1UnormPack16 },
|
|
{ "B5G5R5A1UnormPack16", Format::eB5G5R5A1UnormPack16 },
|
|
{ "A1R5G5B5UnormPack16", Format::eA1R5G5B5UnormPack16 },
|
|
{ "R8Unorm", Format::eR8Unorm },
|
|
{ "R8Snorm", Format::eR8Snorm },
|
|
{ "R8Uscaled", Format::eR8Uscaled },
|
|
{ "R8Sscaled", Format::eR8Sscaled },
|
|
{ "R8Uint", Format::eR8Uint },
|
|
{ "R8Sint", Format::eR8Sint },
|
|
{ "R8Srgb", Format::eR8Srgb },
|
|
{ "R8G8Unorm", Format::eR8G8Unorm },
|
|
{ "R8G8Snorm", Format::eR8G8Snorm },
|
|
{ "R8G8Uscaled", Format::eR8G8Uscaled },
|
|
{ "R8G8Sscaled", Format::eR8G8Sscaled },
|
|
{ "R8G8Uint", Format::eR8G8Uint },
|
|
{ "R8G8Sint", Format::eR8G8Sint },
|
|
{ "R8G8Srgb", Format::eR8G8Srgb },
|
|
{ "R8G8B8Unorm", Format::eR8G8B8Unorm },
|
|
{ "R8G8B8Snorm", Format::eR8G8B8Snorm },
|
|
{ "R8G8B8Uscaled", Format::eR8G8B8Uscaled },
|
|
{ "R8G8B8Sscaled", Format::eR8G8B8Sscaled },
|
|
{ "R8G8B8Uint", Format::eR8G8B8Uint },
|
|
{ "R8G8B8Sint", Format::eR8G8B8Sint },
|
|
{ "R8G8B8Srgb", Format::eR8G8B8Srgb },
|
|
{ "B8G8R8Unorm", Format::eB8G8R8Unorm },
|
|
{ "B8G8R8Snorm", Format::eB8G8R8Snorm },
|
|
{ "B8G8R8Uscaled", Format::eB8G8R8Uscaled },
|
|
{ "B8G8R8Sscaled", Format::eB8G8R8Sscaled },
|
|
{ "B8G8R8Uint", Format::eB8G8R8Uint },
|
|
{ "B8G8R8Sint", Format::eB8G8R8Sint },
|
|
{ "B8G8R8Srgb", Format::eB8G8R8Srgb },
|
|
{ "R8G8B8A8Unorm", Format::eR8G8B8A8Unorm },
|
|
{ "R8G8B8A8Snorm", Format::eR8G8B8A8Snorm },
|
|
{ "R8G8B8A8Uscaled", Format::eR8G8B8A8Uscaled },
|
|
{ "R8G8B8A8Sscaled", Format::eR8G8B8A8Sscaled },
|
|
{ "R8G8B8A8Uint", Format::eR8G8B8A8Uint },
|
|
{ "R8G8B8A8Sint", Format::eR8G8B8A8Sint },
|
|
{ "R8G8B8A8Srgb", Format::eR8G8B8A8Srgb },
|
|
{ "B8G8R8A8Unorm", Format::eB8G8R8A8Unorm },
|
|
{ "B8G8R8A8Snorm", Format::eB8G8R8A8Snorm },
|
|
{ "B8G8R8A8Uscaled", Format::eB8G8R8A8Uscaled },
|
|
{ "B8G8R8A8Sscaled", Format::eB8G8R8A8Sscaled },
|
|
{ "B8G8R8A8Uint", Format::eB8G8R8A8Uint },
|
|
{ "B8G8R8A8Sint", Format::eB8G8R8A8Sint },
|
|
{ "B8G8R8A8Srgb", Format::eB8G8R8A8Srgb },
|
|
{ "A8B8G8R8UnormPack32", Format::eA8B8G8R8UnormPack32 },
|
|
{ "A8B8G8R8SnormPack32", Format::eA8B8G8R8SnormPack32 },
|
|
{ "A8B8G8R8UscaledPack32", Format::eA8B8G8R8UscaledPack32 },
|
|
{ "A8B8G8R8SscaledPack32", Format::eA8B8G8R8SscaledPack32 },
|
|
{ "A8B8G8R8UintPack32", Format::eA8B8G8R8UintPack32 },
|
|
{ "A8B8G8R8SintPack32", Format::eA8B8G8R8SintPack32 },
|
|
{ "A8B8G8R8SrgbPack32", Format::eA8B8G8R8SrgbPack32 },
|
|
{ "A2R10G10B10UnormPack32", Format::eA2R10G10B10UnormPack32 },
|
|
{ "A2R10G10B10SnormPack32", Format::eA2R10G10B10SnormPack32 },
|
|
{ "A2R10G10B10UscaledPack32", Format::eA2R10G10B10UscaledPack32 },
|
|
{ "A2R10G10B10SscaledPack32", Format::eA2R10G10B10SscaledPack32 },
|
|
{ "A2R10G10B10UintPack32", Format::eA2R10G10B10UintPack32 },
|
|
{ "A2R10G10B10SintPack32", Format::eA2R10G10B10SintPack32 },
|
|
{ "A2B10G10R10UnormPack32", Format::eA2B10G10R10UnormPack32 },
|
|
{ "A2B10G10R10SnormPack32", Format::eA2B10G10R10SnormPack32 },
|
|
{ "A2B10G10R10UscaledPack32", Format::eA2B10G10R10UscaledPack32 },
|
|
{ "A2B10G10R10SscaledPack32", Format::eA2B10G10R10SscaledPack32 },
|
|
{ "A2B10G10R10UintPack32", Format::eA2B10G10R10UintPack32 },
|
|
{ "A2B10G10R10SintPack32", Format::eA2B10G10R10SintPack32 },
|
|
{ "R16Unorm", Format::eR16Unorm },
|
|
{ "R16Snorm", Format::eR16Snorm },
|
|
{ "R16Uscaled", Format::eR16Uscaled },
|
|
{ "R16Sscaled", Format::eR16Sscaled },
|
|
{ "R16Uint", Format::eR16Uint },
|
|
{ "R16Sint", Format::eR16Sint },
|
|
{ "R16Sfloat", Format::eR16Sfloat },
|
|
{ "R16G16Unorm", Format::eR16G16Unorm },
|
|
{ "R16G16Snorm", Format::eR16G16Snorm },
|
|
{ "R16G16Uscaled", Format::eR16G16Uscaled },
|
|
{ "R16G16Sscaled", Format::eR16G16Sscaled },
|
|
{ "R16G16Uint", Format::eR16G16Uint },
|
|
{ "R16G16Sint", Format::eR16G16Sint },
|
|
{ "R16G16Sfloat", Format::eR16G16Sfloat },
|
|
{ "R16G16B16Unorm", Format::eR16G16B16Unorm },
|
|
{ "R16G16B16Snorm", Format::eR16G16B16Snorm },
|
|
{ "R16G16B16Uscaled", Format::eR16G16B16Uscaled },
|
|
{ "R16G16B16Sscaled", Format::eR16G16B16Sscaled },
|
|
{ "R16G16B16Uint", Format::eR16G16B16Uint },
|
|
{ "R16G16B16Sint", Format::eR16G16B16Sint },
|
|
{ "R16G16B16Sfloat", Format::eR16G16B16Sfloat },
|
|
{ "R16G16B16A16Unorm", Format::eR16G16B16A16Unorm },
|
|
{ "R16G16B16A16Snorm", Format::eR16G16B16A16Snorm },
|
|
{ "R16G16B16A16Uscaled", Format::eR16G16B16A16Uscaled },
|
|
{ "R16G16B16A16Sscaled", Format::eR16G16B16A16Sscaled },
|
|
{ "R16G16B16A16Uint", Format::eR16G16B16A16Uint },
|
|
{ "R16G16B16A16Sint", Format::eR16G16B16A16Sint },
|
|
{ "R16G16B16A16Sfloat", Format::eR16G16B16A16Sfloat },
|
|
{ "R32Uint", Format::eR32Uint },
|
|
{ "R32Sint", Format::eR32Sint },
|
|
{ "R32Sfloat", Format::eR32Sfloat },
|
|
{ "R32G32Uint", Format::eR32G32Uint },
|
|
{ "R32G32Sint", Format::eR32G32Sint },
|
|
{ "R32G32Sfloat", Format::eR32G32Sfloat },
|
|
{ "R32G32B32Uint", Format::eR32G32B32Uint },
|
|
{ "R32G32B32Sint", Format::eR32G32B32Sint },
|
|
{ "R32G32B32Sfloat", Format::eR32G32B32Sfloat },
|
|
{ "R32G32B32A32Uint", Format::eR32G32B32A32Uint },
|
|
{ "R32G32B32A32Sint", Format::eR32G32B32A32Sint },
|
|
{ "R32G32B32A32Sfloat", Format::eR32G32B32A32Sfloat },
|
|
{ "R64Uint", Format::eR64Uint },
|
|
{ "R64Sint", Format::eR64Sint },
|
|
{ "R64Sfloat", Format::eR64Sfloat },
|
|
{ "R64G64Uint", Format::eR64G64Uint },
|
|
{ "R64G64Sint", Format::eR64G64Sint },
|
|
{ "R64G64Sfloat", Format::eR64G64Sfloat },
|
|
{ "R64G64B64Uint", Format::eR64G64B64Uint },
|
|
{ "R64G64B64Sint", Format::eR64G64B64Sint },
|
|
{ "R64G64B64Sfloat", Format::eR64G64B64Sfloat },
|
|
{ "R64G64B64A64Uint", Format::eR64G64B64A64Uint },
|
|
{ "R64G64B64A64Sint", Format::eR64G64B64A64Sint },
|
|
{ "R64G64B64A64Sfloat", Format::eR64G64B64A64Sfloat },
|
|
{ "B10G11R11UfloatPack32", Format::eB10G11R11UfloatPack32 },
|
|
{ "E5B9G9R9UfloatPack32", Format::eE5B9G9R9UfloatPack32 },
|
|
{ "D16Unorm", Format::eD16Unorm },
|
|
{ "X8D24UnormPack32", Format::eX8D24UnormPack32 },
|
|
{ "D32Sfloat", Format::eD32Sfloat },
|
|
{ "S8Uint", Format::eS8Uint },
|
|
{ "D16UnormS8Uint", Format::eD16UnormS8Uint },
|
|
{ "D24UnormS8Uint", Format::eD24UnormS8Uint },
|
|
{ "D32SfloatS8Uint", Format::eD32SfloatS8Uint },
|
|
{ "Bc1RgbUnormBlock", Format::eBc1RgbUnormBlock },
|
|
{ "Bc1RgbSrgbBlock", Format::eBc1RgbSrgbBlock },
|
|
{ "Bc1RgbaUnormBlock", Format::eBc1RgbaUnormBlock },
|
|
{ "Bc1RgbaSrgbBlock", Format::eBc1RgbaSrgbBlock },
|
|
{ "Bc2UnormBlock", Format::eBc2UnormBlock },
|
|
{ "Bc2SrgbBlock", Format::eBc2SrgbBlock },
|
|
{ "Bc3UnormBlock", Format::eBc3UnormBlock },
|
|
{ "Bc3SrgbBlock", Format::eBc3SrgbBlock },
|
|
{ "Bc4UnormBlock", Format::eBc4UnormBlock },
|
|
{ "Bc4SnormBlock", Format::eBc4SnormBlock },
|
|
{ "Bc5UnormBlock", Format::eBc5UnormBlock },
|
|
{ "Bc5SnormBlock", Format::eBc5SnormBlock },
|
|
{ "Bc6HUfloatBlock", Format::eBc6HUfloatBlock },
|
|
{ "Bc6HSfloatBlock", Format::eBc6HSfloatBlock },
|
|
{ "Bc7UnormBlock", Format::eBc7UnormBlock },
|
|
{ "Bc7SrgbBlock", Format::eBc7SrgbBlock },
|
|
{ "Etc2R8G8B8UnormBlock", Format::eEtc2R8G8B8UnormBlock },
|
|
{ "Etc2R8G8B8SrgbBlock", Format::eEtc2R8G8B8SrgbBlock },
|
|
{ "Etc2R8G8B8A1UnormBlock", Format::eEtc2R8G8B8A1UnormBlock },
|
|
{ "Etc2R8G8B8A1SrgbBlock", Format::eEtc2R8G8B8A1SrgbBlock },
|
|
{ "Etc2R8G8B8A8UnormBlock", Format::eEtc2R8G8B8A8UnormBlock },
|
|
{ "Etc2R8G8B8A8SrgbBlock", Format::eEtc2R8G8B8A8SrgbBlock },
|
|
{ "EacR11UnormBlock", Format::eEacR11UnormBlock },
|
|
{ "EacR11SnormBlock", Format::eEacR11SnormBlock },
|
|
{ "EacR11G11UnormBlock", Format::eEacR11G11UnormBlock },
|
|
{ "EacR11G11SnormBlock", Format::eEacR11G11SnormBlock },
|
|
{ "Astc4x4UnormBlock", Format::eAstc4x4UnormBlock },
|
|
{ "Astc4x4SrgbBlock", Format::eAstc4x4SrgbBlock },
|
|
{ "Astc5x4UnormBlock", Format::eAstc5x4UnormBlock },
|
|
{ "Astc5x4SrgbBlock", Format::eAstc5x4SrgbBlock },
|
|
{ "Astc5x5UnormBlock", Format::eAstc5x5UnormBlock },
|
|
{ "Astc5x5SrgbBlock", Format::eAstc5x5SrgbBlock },
|
|
{ "Astc6x5UnormBlock", Format::eAstc6x5UnormBlock },
|
|
{ "Astc6x5SrgbBlock", Format::eAstc6x5SrgbBlock },
|
|
{ "Astc6x6UnormBlock", Format::eAstc6x6UnormBlock },
|
|
{ "Astc6x6SrgbBlock", Format::eAstc6x6SrgbBlock },
|
|
{ "Astc8x5UnormBlock", Format::eAstc8x5UnormBlock },
|
|
{ "Astc8x5SrgbBlock", Format::eAstc8x5SrgbBlock },
|
|
{ "Astc8x6UnormBlock", Format::eAstc8x6UnormBlock },
|
|
{ "Astc8x6SrgbBlock", Format::eAstc8x6SrgbBlock },
|
|
{ "Astc8x8UnormBlock", Format::eAstc8x8UnormBlock },
|
|
{ "Astc8x8SrgbBlock", Format::eAstc8x8SrgbBlock },
|
|
{ "Astc10x5UnormBlock", Format::eAstc10x5UnormBlock },
|
|
{ "Astc10x5SrgbBlock", Format::eAstc10x5SrgbBlock },
|
|
{ "Astc10x6UnormBlock", Format::eAstc10x6UnormBlock },
|
|
{ "Astc10x6SrgbBlock", Format::eAstc10x6SrgbBlock },
|
|
{ "Astc10x8UnormBlock", Format::eAstc10x8UnormBlock },
|
|
{ "Astc10x8SrgbBlock", Format::eAstc10x8SrgbBlock },
|
|
{ "Astc10x10UnormBlock", Format::eAstc10x10UnormBlock },
|
|
{ "Astc10x10SrgbBlock", Format::eAstc10x10SrgbBlock },
|
|
{ "Astc12x10UnormBlock", Format::eAstc12x10UnormBlock },
|
|
{ "Astc12x10SrgbBlock", Format::eAstc12x10SrgbBlock },
|
|
{ "Astc12x12UnormBlock", Format::eAstc12x12UnormBlock },
|
|
{ "Astc12x12SrgbBlock", Format::eAstc12x12SrgbBlock },
|
|
{ "G8B8G8R8422Unorm", Format::eG8B8G8R8422Unorm },
|
|
{ "B8G8R8G8422Unorm", Format::eB8G8R8G8422Unorm },
|
|
{ "G8B8R83Plane420Unorm", Format::eG8B8R83Plane420Unorm },
|
|
{ "G8B8R82Plane420Unorm", Format::eG8B8R82Plane420Unorm },
|
|
{ "G8B8R83Plane422Unorm", Format::eG8B8R83Plane422Unorm },
|
|
{ "G8B8R82Plane422Unorm", Format::eG8B8R82Plane422Unorm },
|
|
{ "G8B8R83Plane444Unorm", Format::eG8B8R83Plane444Unorm },
|
|
{ "R10X6UnormPack16", Format::eR10X6UnormPack16 },
|
|
{ "R10X6G10X6Unorm2Pack16", Format::eR10X6G10X6Unorm2Pack16 },
|
|
{ "R10X6G10X6B10X6A10X6Unorm4Pack16", Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 },
|
|
{ "G10X6B10X6G10X6R10X6422Unorm4Pack16", Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 },
|
|
{ "B10X6G10X6R10X6G10X6422Unorm4Pack16", Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 },
|
|
{ "G10X6B10X6R10X63Plane420Unorm3Pack16", Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 },
|
|
{ "G10X6B10X6R10X62Plane420Unorm3Pack16", Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 },
|
|
{ "G10X6B10X6R10X63Plane422Unorm3Pack16", Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 },
|
|
{ "G10X6B10X6R10X62Plane422Unorm3Pack16", Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 },
|
|
{ "G10X6B10X6R10X63Plane444Unorm3Pack16", Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 },
|
|
{ "R12X4UnormPack16", Format::eR12X4UnormPack16 },
|
|
{ "R12X4G12X4Unorm2Pack16", Format::eR12X4G12X4Unorm2Pack16 },
|
|
{ "R12X4G12X4B12X4A12X4Unorm4Pack16", Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 },
|
|
{ "G12X4B12X4G12X4R12X4422Unorm4Pack16", Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 },
|
|
{ "B12X4G12X4R12X4G12X4422Unorm4Pack16", Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 },
|
|
{ "G12X4B12X4R12X43Plane420Unorm3Pack16", Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 },
|
|
{ "G12X4B12X4R12X42Plane420Unorm3Pack16", Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 },
|
|
{ "G12X4B12X4R12X43Plane422Unorm3Pack16", Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 },
|
|
{ "G12X4B12X4R12X42Plane422Unorm3Pack16", Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 },
|
|
{ "G12X4B12X4R12X43Plane444Unorm3Pack16", Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 },
|
|
{ "G16B16G16R16422Unorm", Format::eG16B16G16R16422Unorm },
|
|
{ "B16G16R16G16422Unorm", Format::eB16G16R16G16422Unorm },
|
|
{ "G16B16R163Plane420Unorm", Format::eG16B16R163Plane420Unorm },
|
|
{ "G16B16R162Plane420Unorm", Format::eG16B16R162Plane420Unorm },
|
|
{ "G16B16R163Plane422Unorm", Format::eG16B16R163Plane422Unorm },
|
|
{ "G16B16R162Plane422Unorm", Format::eG16B16R162Plane422Unorm },
|
|
{ "G16B16R163Plane444Unorm", Format::eG16B16R163Plane444Unorm },
|
|
{ "G8B8R82Plane444Unorm", Format::eG8B8R82Plane444Unorm },
|
|
{ "G10X6B10X6R10X62Plane444Unorm3Pack16", Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 },
|
|
{ "G12X4B12X4R12X42Plane444Unorm3Pack16", Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 },
|
|
{ "G16B16R162Plane444Unorm", Format::eG16B16R162Plane444Unorm },
|
|
{ "A4R4G4B4UnormPack16", Format::eA4R4G4B4UnormPack16 },
|
|
{ "A4B4G4R4UnormPack16", Format::eA4B4G4R4UnormPack16 },
|
|
{ "Astc4x4SfloatBlock", Format::eAstc4x4SfloatBlock },
|
|
{ "Astc5x4SfloatBlock", Format::eAstc5x4SfloatBlock },
|
|
{ "Astc5x5SfloatBlock", Format::eAstc5x5SfloatBlock },
|
|
{ "Astc6x5SfloatBlock", Format::eAstc6x5SfloatBlock },
|
|
{ "Astc6x6SfloatBlock", Format::eAstc6x6SfloatBlock },
|
|
{ "Astc8x5SfloatBlock", Format::eAstc8x5SfloatBlock },
|
|
{ "Astc8x6SfloatBlock", Format::eAstc8x6SfloatBlock },
|
|
{ "Astc8x8SfloatBlock", Format::eAstc8x8SfloatBlock },
|
|
{ "Astc10x5SfloatBlock", Format::eAstc10x5SfloatBlock },
|
|
{ "Astc10x6SfloatBlock", Format::eAstc10x6SfloatBlock },
|
|
{ "Astc10x8SfloatBlock", Format::eAstc10x8SfloatBlock },
|
|
{ "Astc10x10SfloatBlock", Format::eAstc10x10SfloatBlock },
|
|
{ "Astc12x10SfloatBlock", Format::eAstc12x10SfloatBlock },
|
|
{ "Astc12x12SfloatBlock", Format::eAstc12x12SfloatBlock },
|
|
{ "Pvrtc12BppUnormBlockIMG", Format::ePvrtc12BppUnormBlockIMG },
|
|
{ "Pvrtc14BppUnormBlockIMG", Format::ePvrtc14BppUnormBlockIMG },
|
|
{ "Pvrtc22BppUnormBlockIMG", Format::ePvrtc22BppUnormBlockIMG },
|
|
{ "Pvrtc24BppUnormBlockIMG", Format::ePvrtc24BppUnormBlockIMG },
|
|
{ "Pvrtc12BppSrgbBlockIMG", Format::ePvrtc12BppSrgbBlockIMG },
|
|
{ "Pvrtc14BppSrgbBlockIMG", Format::ePvrtc14BppSrgbBlockIMG },
|
|
{ "Pvrtc22BppSrgbBlockIMG", Format::ePvrtc22BppSrgbBlockIMG },
|
|
{ "Pvrtc24BppSrgbBlockIMG", Format::ePvrtc24BppSrgbBlockIMG },
|
|
{ "R16G16S105NV", Format::eR16G16S105NV },
|
|
{ "A1B5G5R5UnormPack16KHR", Format::eA1B5G5R5UnormPack16KHR },
|
|
{ "A8UnormKHR", Format::eA8UnormKHR },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FormatFeatureFlagBits> FormatFeatureFlagBitsEntries = {
|
|
{ "SampledImage", FormatFeatureFlagBits::eSampledImage },
|
|
{ "StorageImage", FormatFeatureFlagBits::eStorageImage },
|
|
{ "StorageImageAtomic", FormatFeatureFlagBits::eStorageImageAtomic },
|
|
{ "UniformTexelBuffer", FormatFeatureFlagBits::eUniformTexelBuffer },
|
|
{ "StorageTexelBuffer", FormatFeatureFlagBits::eStorageTexelBuffer },
|
|
{ "StorageTexelBufferAtomic", FormatFeatureFlagBits::eStorageTexelBufferAtomic },
|
|
{ "VertexBuffer", FormatFeatureFlagBits::eVertexBuffer },
|
|
{ "ColorAttachment", FormatFeatureFlagBits::eColorAttachment },
|
|
{ "ColorAttachmentBlend", FormatFeatureFlagBits::eColorAttachmentBlend },
|
|
{ "DepthStencilAttachment", FormatFeatureFlagBits::eDepthStencilAttachment },
|
|
{ "BlitSrc", FormatFeatureFlagBits::eBlitSrc },
|
|
{ "BlitDst", FormatFeatureFlagBits::eBlitDst },
|
|
{ "SampledImageFilterLinear", FormatFeatureFlagBits::eSampledImageFilterLinear },
|
|
{ "TransferSrc", FormatFeatureFlagBits::eTransferSrc },
|
|
{ "TransferDst", FormatFeatureFlagBits::eTransferDst },
|
|
{ "MidpointChromaSamples", FormatFeatureFlagBits::eMidpointChromaSamples },
|
|
{ "SampledImageYcbcrConversionLinearFilter", FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter },
|
|
{ "SampledImageYcbcrConversionSeparateReconstructionFilter", FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter },
|
|
{ "SampledImageYcbcrConversionChromaReconstructionExplicit", FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit },
|
|
{ "SampledImageYcbcrConversionChromaReconstructionExplicitForceable",
|
|
FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable },
|
|
{ "Disjoint", FormatFeatureFlagBits::eDisjoint },
|
|
{ "CositedChromaSamples", FormatFeatureFlagBits::eCositedChromaSamples },
|
|
{ "SampledImageFilterMinmax", FormatFeatureFlagBits::eSampledImageFilterMinmax },
|
|
{ "VideoDecodeOutputKHR", FormatFeatureFlagBits::eVideoDecodeOutputKHR },
|
|
{ "VideoDecodeDpbKHR", FormatFeatureFlagBits::eVideoDecodeDpbKHR },
|
|
{ "AccelerationStructureVertexBufferKHR", FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR },
|
|
{ "SampledImageFilterCubicEXT", FormatFeatureFlagBits::eSampledImageFilterCubicEXT },
|
|
{ "FragmentDensityMapEXT", FormatFeatureFlagBits::eFragmentDensityMapEXT },
|
|
{ "FragmentShadingRateAttachmentKHR", FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeInputKHR", FormatFeatureFlagBits::eVideoEncodeInputKHR },
|
|
{ "VideoEncodeDpbKHR", FormatFeatureFlagBits::eVideoEncodeDpbKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageCreateFlagBits> ImageCreateFlagBitsEntries = {
|
|
{ "SparseBinding", ImageCreateFlagBits::eSparseBinding },
|
|
{ "SparseResidency", ImageCreateFlagBits::eSparseResidency },
|
|
{ "SparseAliased", ImageCreateFlagBits::eSparseAliased },
|
|
{ "MutableFormat", ImageCreateFlagBits::eMutableFormat },
|
|
{ "CubeCompatible", ImageCreateFlagBits::eCubeCompatible },
|
|
{ "Alias", ImageCreateFlagBits::eAlias },
|
|
{ "SplitInstanceBindRegions", ImageCreateFlagBits::eSplitInstanceBindRegions },
|
|
{ "2DArrayCompatible", ImageCreateFlagBits::e2DArrayCompatible },
|
|
{ "BlockTexelViewCompatible", ImageCreateFlagBits::eBlockTexelViewCompatible },
|
|
{ "ExtendedUsage", ImageCreateFlagBits::eExtendedUsage },
|
|
{ "Protected", ImageCreateFlagBits::eProtected },
|
|
{ "Disjoint", ImageCreateFlagBits::eDisjoint },
|
|
{ "CornerSampledNV", ImageCreateFlagBits::eCornerSampledNV },
|
|
{ "SampleLocationsCompatibleDepthEXT", ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT },
|
|
{ "SubsampledEXT", ImageCreateFlagBits::eSubsampledEXT },
|
|
{ "DescriptorBufferCaptureReplayEXT", ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT },
|
|
{ "MultisampledRenderToSingleSampledEXT", ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT },
|
|
{ "2DViewCompatibleEXT", ImageCreateFlagBits::e2DViewCompatibleEXT },
|
|
{ "FragmentDensityMapOffsetQCOM", ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageTiling> ImageTilingEntries = {
|
|
{ "Optimal", ImageTiling::eOptimal },
|
|
{ "Linear", ImageTiling::eLinear },
|
|
{ "DrmFormatModifierEXT", ImageTiling::eDrmFormatModifierEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageType> ImageTypeEntries = {
|
|
{ "1D", ImageType::e1D },
|
|
{ "2D", ImageType::e2D },
|
|
{ "3D", ImageType::e3D },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageUsageFlagBits> ImageUsageFlagBitsEntries = {
|
|
{ "TransferSrc", ImageUsageFlagBits::eTransferSrc },
|
|
{ "TransferDst", ImageUsageFlagBits::eTransferDst },
|
|
{ "Sampled", ImageUsageFlagBits::eSampled },
|
|
{ "Storage", ImageUsageFlagBits::eStorage },
|
|
{ "ColorAttachment", ImageUsageFlagBits::eColorAttachment },
|
|
{ "DepthStencilAttachment", ImageUsageFlagBits::eDepthStencilAttachment },
|
|
{ "TransientAttachment", ImageUsageFlagBits::eTransientAttachment },
|
|
{ "InputAttachment", ImageUsageFlagBits::eInputAttachment },
|
|
{ "VideoDecodeDstKHR", ImageUsageFlagBits::eVideoDecodeDstKHR },
|
|
{ "VideoDecodeSrcKHR", ImageUsageFlagBits::eVideoDecodeSrcKHR },
|
|
{ "VideoDecodeDpbKHR", ImageUsageFlagBits::eVideoDecodeDpbKHR },
|
|
{ "FragmentDensityMapEXT", ImageUsageFlagBits::eFragmentDensityMapEXT },
|
|
{ "FragmentShadingRateAttachmentKHR", ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR },
|
|
{ "HostTransferEXT", ImageUsageFlagBits::eHostTransferEXT },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeDstKHR", ImageUsageFlagBits::eVideoEncodeDstKHR },
|
|
{ "VideoEncodeSrcKHR", ImageUsageFlagBits::eVideoEncodeSrcKHR },
|
|
{ "VideoEncodeDpbKHR", ImageUsageFlagBits::eVideoEncodeDpbKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "AttachmentFeedbackLoopEXT", ImageUsageFlagBits::eAttachmentFeedbackLoopEXT },
|
|
{ "InvocationMaskHUAWEI", ImageUsageFlagBits::eInvocationMaskHUAWEI },
|
|
{ "SampleWeightQCOM", ImageUsageFlagBits::eSampleWeightQCOM },
|
|
{ "SampleBlockMatchQCOM", ImageUsageFlagBits::eSampleBlockMatchQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, InstanceCreateFlagBits> InstanceCreateFlagBitsEntries = {
|
|
{ "EnumeratePortabilityKHR", InstanceCreateFlagBits::eEnumeratePortabilityKHR },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, InternalAllocationType> InternalAllocationTypeEntries = {
|
|
{ "Executable", InternalAllocationType::eExecutable },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MemoryHeapFlagBits> MemoryHeapFlagBitsEntries = {
|
|
{ "DeviceLocal", MemoryHeapFlagBits::eDeviceLocal },
|
|
{ "MultiInstance", MemoryHeapFlagBits::eMultiInstance },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MemoryPropertyFlagBits> MemoryPropertyFlagBitsEntries = {
|
|
{ "DeviceLocal", MemoryPropertyFlagBits::eDeviceLocal },
|
|
{ "HostVisible", MemoryPropertyFlagBits::eHostVisible },
|
|
{ "HostCoherent", MemoryPropertyFlagBits::eHostCoherent },
|
|
{ "HostCached", MemoryPropertyFlagBits::eHostCached },
|
|
{ "LazilyAllocated", MemoryPropertyFlagBits::eLazilyAllocated },
|
|
{ "Protected", MemoryPropertyFlagBits::eProtected },
|
|
{ "DeviceCoherentAMD", MemoryPropertyFlagBits::eDeviceCoherentAMD },
|
|
{ "DeviceUncachedAMD", MemoryPropertyFlagBits::eDeviceUncachedAMD },
|
|
{ "RdmaCapableNV", MemoryPropertyFlagBits::eRdmaCapableNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PhysicalDeviceType> PhysicalDeviceTypeEntries = {
|
|
{ "Other", PhysicalDeviceType::eOther },
|
|
{ "IntegratedGpu", PhysicalDeviceType::eIntegratedGpu },
|
|
{ "DiscreteGpu", PhysicalDeviceType::eDiscreteGpu },
|
|
{ "VirtualGpu", PhysicalDeviceType::eVirtualGpu },
|
|
{ "Cpu", PhysicalDeviceType::eCpu },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueueFlagBits> QueueFlagBitsEntries = {
|
|
{ "Graphics", QueueFlagBits::eGraphics },
|
|
{ "Compute", QueueFlagBits::eCompute },
|
|
{ "Transfer", QueueFlagBits::eTransfer },
|
|
{ "SparseBinding", QueueFlagBits::eSparseBinding },
|
|
{ "Protected", QueueFlagBits::eProtected },
|
|
{ "VideoDecodeKHR", QueueFlagBits::eVideoDecodeKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeKHR", QueueFlagBits::eVideoEncodeKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "OpticalFlowNV", QueueFlagBits::eOpticalFlowNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SampleCountFlagBits> SampleCountFlagBitsEntries = {
|
|
{ "1", SampleCountFlagBits::e1 }, { "2", SampleCountFlagBits::e2 }, { "4", SampleCountFlagBits::e4 }, { "8", SampleCountFlagBits::e8 },
|
|
{ "16", SampleCountFlagBits::e16 }, { "32", SampleCountFlagBits::e32 }, { "64", SampleCountFlagBits::e64 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SystemAllocationScope> SystemAllocationScopeEntries = {
|
|
{ "Command", SystemAllocationScope::eCommand }, { "Object", SystemAllocationScope::eObject }, { "Cache", SystemAllocationScope::eCache },
|
|
{ "Device", SystemAllocationScope::eDevice }, { "Instance", SystemAllocationScope::eInstance },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceCreateFlagBits> DeviceCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceQueueCreateFlagBits> DeviceQueueCreateFlagBitsEntries = {
|
|
{ "Protected", DeviceQueueCreateFlagBits::eProtected },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineStageFlagBits> PipelineStageFlagBitsEntries = {
|
|
{ "TopOfPipe", PipelineStageFlagBits::eTopOfPipe },
|
|
{ "DrawIndirect", PipelineStageFlagBits::eDrawIndirect },
|
|
{ "VertexInput", PipelineStageFlagBits::eVertexInput },
|
|
{ "VertexShader", PipelineStageFlagBits::eVertexShader },
|
|
{ "TessellationControlShader", PipelineStageFlagBits::eTessellationControlShader },
|
|
{ "TessellationEvaluationShader", PipelineStageFlagBits::eTessellationEvaluationShader },
|
|
{ "GeometryShader", PipelineStageFlagBits::eGeometryShader },
|
|
{ "FragmentShader", PipelineStageFlagBits::eFragmentShader },
|
|
{ "EarlyFragmentTests", PipelineStageFlagBits::eEarlyFragmentTests },
|
|
{ "LateFragmentTests", PipelineStageFlagBits::eLateFragmentTests },
|
|
{ "ColorAttachmentOutput", PipelineStageFlagBits::eColorAttachmentOutput },
|
|
{ "ComputeShader", PipelineStageFlagBits::eComputeShader },
|
|
{ "Transfer", PipelineStageFlagBits::eTransfer },
|
|
{ "BottomOfPipe", PipelineStageFlagBits::eBottomOfPipe },
|
|
{ "Host", PipelineStageFlagBits::eHost },
|
|
{ "AllGraphics", PipelineStageFlagBits::eAllGraphics },
|
|
{ "AllCommands", PipelineStageFlagBits::eAllCommands },
|
|
{ "None", PipelineStageFlagBits::eNone },
|
|
{ "TransformFeedbackEXT", PipelineStageFlagBits::eTransformFeedbackEXT },
|
|
{ "ConditionalRenderingEXT", PipelineStageFlagBits::eConditionalRenderingEXT },
|
|
{ "AccelerationStructureBuildKHR", PipelineStageFlagBits::eAccelerationStructureBuildKHR },
|
|
{ "RayTracingShaderKHR", PipelineStageFlagBits::eRayTracingShaderKHR },
|
|
{ "FragmentDensityProcessEXT", PipelineStageFlagBits::eFragmentDensityProcessEXT },
|
|
{ "FragmentShadingRateAttachmentKHR", PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR },
|
|
{ "CommandPreprocessNV", PipelineStageFlagBits::eCommandPreprocessNV },
|
|
{ "TaskShaderEXT", PipelineStageFlagBits::eTaskShaderEXT },
|
|
{ "MeshShaderEXT", PipelineStageFlagBits::eMeshShaderEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MemoryMapFlagBits> MemoryMapFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageAspectFlagBits> ImageAspectFlagBitsEntries = {
|
|
{ "Color", ImageAspectFlagBits::eColor },
|
|
{ "Depth", ImageAspectFlagBits::eDepth },
|
|
{ "Stencil", ImageAspectFlagBits::eStencil },
|
|
{ "Metadata", ImageAspectFlagBits::eMetadata },
|
|
{ "Plane0", ImageAspectFlagBits::ePlane0 },
|
|
{ "Plane1", ImageAspectFlagBits::ePlane1 },
|
|
{ "Plane2", ImageAspectFlagBits::ePlane2 },
|
|
{ "None", ImageAspectFlagBits::eNone },
|
|
{ "MemoryPlane0EXT", ImageAspectFlagBits::eMemoryPlane0EXT },
|
|
{ "MemoryPlane1EXT", ImageAspectFlagBits::eMemoryPlane1EXT },
|
|
{ "MemoryPlane2EXT", ImageAspectFlagBits::eMemoryPlane2EXT },
|
|
{ "MemoryPlane3EXT", ImageAspectFlagBits::eMemoryPlane3EXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SparseImageFormatFlagBits> SparseImageFormatFlagBitsEntries = {
|
|
{ "SingleMiptail", SparseImageFormatFlagBits::eSingleMiptail },
|
|
{ "AlignedMipSize", SparseImageFormatFlagBits::eAlignedMipSize },
|
|
{ "NonstandardBlockSize", SparseImageFormatFlagBits::eNonstandardBlockSize },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SparseMemoryBindFlagBits> SparseMemoryBindFlagBitsEntries = {
|
|
{ "Metadata", SparseMemoryBindFlagBits::eMetadata },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FenceCreateFlagBits> FenceCreateFlagBitsEntries = {
|
|
{ "Signaled", FenceCreateFlagBits::eSignaled },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreCreateFlagBits> SemaphoreCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, EventCreateFlagBits> EventCreateFlagBitsEntries = {
|
|
{ "DeviceOnly", EventCreateFlagBits::eDeviceOnly },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryPipelineStatisticFlagBits> QueryPipelineStatisticFlagBitsEntries = {
|
|
{ "InputAssemblyVertices", QueryPipelineStatisticFlagBits::eInputAssemblyVertices },
|
|
{ "InputAssemblyPrimitives", QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives },
|
|
{ "VertexShaderInvocations", QueryPipelineStatisticFlagBits::eVertexShaderInvocations },
|
|
{ "GeometryShaderInvocations", QueryPipelineStatisticFlagBits::eGeometryShaderInvocations },
|
|
{ "GeometryShaderPrimitives", QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives },
|
|
{ "ClippingInvocations", QueryPipelineStatisticFlagBits::eClippingInvocations },
|
|
{ "ClippingPrimitives", QueryPipelineStatisticFlagBits::eClippingPrimitives },
|
|
{ "FragmentShaderInvocations", QueryPipelineStatisticFlagBits::eFragmentShaderInvocations },
|
|
{ "TessellationControlShaderPatches", QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches },
|
|
{ "TessellationEvaluationShaderInvocations", QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations },
|
|
{ "ComputeShaderInvocations", QueryPipelineStatisticFlagBits::eComputeShaderInvocations },
|
|
{ "TaskShaderInvocationsEXT", QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT },
|
|
{ "MeshShaderInvocationsEXT", QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT },
|
|
{ "ClusterCullingShaderInvocationsHUAWEI", QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryResultFlagBits> QueryResultFlagBitsEntries = {
|
|
{ "64", QueryResultFlagBits::e64 },
|
|
{ "Wait", QueryResultFlagBits::eWait },
|
|
{ "WithAvailability", QueryResultFlagBits::eWithAvailability },
|
|
{ "Partial", QueryResultFlagBits::ePartial },
|
|
{ "WithStatusKHR", QueryResultFlagBits::eWithStatusKHR },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryType> QueryTypeEntries = {
|
|
{ "Occlusion", QueryType::eOcclusion },
|
|
{ "PipelineStatistics", QueryType::ePipelineStatistics },
|
|
{ "Timestamp", QueryType::eTimestamp },
|
|
{ "ResultStatusOnlyKHR", QueryType::eResultStatusOnlyKHR },
|
|
{ "TransformFeedbackStreamEXT", QueryType::eTransformFeedbackStreamEXT },
|
|
{ "PerformanceQueryKHR", QueryType::ePerformanceQueryKHR },
|
|
{ "AccelerationStructureCompactedSizeKHR", QueryType::eAccelerationStructureCompactedSizeKHR },
|
|
{ "AccelerationStructureSerializationSizeKHR", QueryType::eAccelerationStructureSerializationSizeKHR },
|
|
{ "AccelerationStructureCompactedSizeNV", QueryType::eAccelerationStructureCompactedSizeNV },
|
|
{ "PerformanceQueryINTEL", QueryType::ePerformanceQueryINTEL },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeFeedbackKHR", QueryType::eVideoEncodeFeedbackKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "MeshPrimitivesGeneratedEXT", QueryType::eMeshPrimitivesGeneratedEXT },
|
|
{ "PrimitivesGeneratedEXT", QueryType::ePrimitivesGeneratedEXT },
|
|
{ "AccelerationStructureSerializationBottomLevelPointersKHR", QueryType::eAccelerationStructureSerializationBottomLevelPointersKHR },
|
|
{ "AccelerationStructureSizeKHR", QueryType::eAccelerationStructureSizeKHR },
|
|
{ "MicromapSerializationSizeEXT", QueryType::eMicromapSerializationSizeEXT },
|
|
{ "MicromapCompactedSizeEXT", QueryType::eMicromapCompactedSizeEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryPoolCreateFlagBits> QueryPoolCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BufferCreateFlagBits> BufferCreateFlagBitsEntries = {
|
|
{ "SparseBinding", BufferCreateFlagBits::eSparseBinding },
|
|
{ "SparseResidency", BufferCreateFlagBits::eSparseResidency },
|
|
{ "SparseAliased", BufferCreateFlagBits::eSparseAliased },
|
|
{ "Protected", BufferCreateFlagBits::eProtected },
|
|
{ "DeviceAddressCaptureReplay", BufferCreateFlagBits::eDeviceAddressCaptureReplay },
|
|
{ "DescriptorBufferCaptureReplayEXT", BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BufferUsageFlagBits> BufferUsageFlagBitsEntries = {
|
|
{ "TransferSrc", BufferUsageFlagBits::eTransferSrc },
|
|
{ "TransferDst", BufferUsageFlagBits::eTransferDst },
|
|
{ "UniformTexelBuffer", BufferUsageFlagBits::eUniformTexelBuffer },
|
|
{ "StorageTexelBuffer", BufferUsageFlagBits::eStorageTexelBuffer },
|
|
{ "UniformBuffer", BufferUsageFlagBits::eUniformBuffer },
|
|
{ "StorageBuffer", BufferUsageFlagBits::eStorageBuffer },
|
|
{ "IndexBuffer", BufferUsageFlagBits::eIndexBuffer },
|
|
{ "VertexBuffer", BufferUsageFlagBits::eVertexBuffer },
|
|
{ "IndirectBuffer", BufferUsageFlagBits::eIndirectBuffer },
|
|
{ "ShaderDeviceAddress", BufferUsageFlagBits::eShaderDeviceAddress },
|
|
{ "VideoDecodeSrcKHR", BufferUsageFlagBits::eVideoDecodeSrcKHR },
|
|
{ "VideoDecodeDstKHR", BufferUsageFlagBits::eVideoDecodeDstKHR },
|
|
{ "TransformFeedbackBufferEXT", BufferUsageFlagBits::eTransformFeedbackBufferEXT },
|
|
{ "TransformFeedbackCounterBufferEXT", BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT },
|
|
{ "ConditionalRenderingEXT", BufferUsageFlagBits::eConditionalRenderingEXT },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "ExecutionGraphScratchAMDX", BufferUsageFlagBits::eExecutionGraphScratchAMDX },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "AccelerationStructureBuildInputReadOnlyKHR", BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR },
|
|
{ "AccelerationStructureStorageKHR", BufferUsageFlagBits::eAccelerationStructureStorageKHR },
|
|
{ "ShaderBindingTableKHR", BufferUsageFlagBits::eShaderBindingTableKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeDstKHR", BufferUsageFlagBits::eVideoEncodeDstKHR },
|
|
{ "VideoEncodeSrcKHR", BufferUsageFlagBits::eVideoEncodeSrcKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "SamplerDescriptorBufferEXT", BufferUsageFlagBits::eSamplerDescriptorBufferEXT },
|
|
{ "ResourceDescriptorBufferEXT", BufferUsageFlagBits::eResourceDescriptorBufferEXT },
|
|
{ "PushDescriptorsDescriptorBufferEXT", BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT },
|
|
{ "MicromapBuildInputReadOnlyEXT", BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT },
|
|
{ "MicromapStorageEXT", BufferUsageFlagBits::eMicromapStorageEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SharingMode> SharingModeEntries = {
|
|
{ "Exclusive", SharingMode::eExclusive },
|
|
{ "Concurrent", SharingMode::eConcurrent },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BufferViewCreateFlagBits> BufferViewCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageLayout> ImageLayoutEntries = {
|
|
{ "Undefined", ImageLayout::eUndefined },
|
|
{ "General", ImageLayout::eGeneral },
|
|
{ "ColorAttachmentOptimal", ImageLayout::eColorAttachmentOptimal },
|
|
{ "DepthStencilAttachmentOptimal", ImageLayout::eDepthStencilAttachmentOptimal },
|
|
{ "DepthStencilReadOnlyOptimal", ImageLayout::eDepthStencilReadOnlyOptimal },
|
|
{ "ShaderReadOnlyOptimal", ImageLayout::eShaderReadOnlyOptimal },
|
|
{ "TransferSrcOptimal", ImageLayout::eTransferSrcOptimal },
|
|
{ "TransferDstOptimal", ImageLayout::eTransferDstOptimal },
|
|
{ "Preinitialized", ImageLayout::ePreinitialized },
|
|
{ "DepthReadOnlyStencilAttachmentOptimal", ImageLayout::eDepthReadOnlyStencilAttachmentOptimal },
|
|
{ "DepthAttachmentStencilReadOnlyOptimal", ImageLayout::eDepthAttachmentStencilReadOnlyOptimal },
|
|
{ "DepthAttachmentOptimal", ImageLayout::eDepthAttachmentOptimal },
|
|
{ "DepthReadOnlyOptimal", ImageLayout::eDepthReadOnlyOptimal },
|
|
{ "StencilAttachmentOptimal", ImageLayout::eStencilAttachmentOptimal },
|
|
{ "StencilReadOnlyOptimal", ImageLayout::eStencilReadOnlyOptimal },
|
|
{ "ReadOnlyOptimal", ImageLayout::eReadOnlyOptimal },
|
|
{ "AttachmentOptimal", ImageLayout::eAttachmentOptimal },
|
|
{ "PresentSrcKHR", ImageLayout::ePresentSrcKHR },
|
|
{ "VideoDecodeDstKHR", ImageLayout::eVideoDecodeDstKHR },
|
|
{ "VideoDecodeSrcKHR", ImageLayout::eVideoDecodeSrcKHR },
|
|
{ "VideoDecodeDpbKHR", ImageLayout::eVideoDecodeDpbKHR },
|
|
{ "SharedPresentKHR", ImageLayout::eSharedPresentKHR },
|
|
{ "FragmentDensityMapOptimalEXT", ImageLayout::eFragmentDensityMapOptimalEXT },
|
|
{ "FragmentShadingRateAttachmentOptimalKHR", ImageLayout::eFragmentShadingRateAttachmentOptimalKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeDstKHR", ImageLayout::eVideoEncodeDstKHR },
|
|
{ "VideoEncodeSrcKHR", ImageLayout::eVideoEncodeSrcKHR },
|
|
{ "VideoEncodeDpbKHR", ImageLayout::eVideoEncodeDpbKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "AttachmentFeedbackLoopOptimalEXT", ImageLayout::eAttachmentFeedbackLoopOptimalEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ComponentSwizzle> ComponentSwizzleEntries = {
|
|
{ "Identity", ComponentSwizzle::eIdentity },
|
|
{ "Zero", ComponentSwizzle::eZero },
|
|
{ "One", ComponentSwizzle::eOne },
|
|
{ "R", ComponentSwizzle::eR },
|
|
{ "G", ComponentSwizzle::eG },
|
|
{ "B", ComponentSwizzle::eB },
|
|
{ "A", ComponentSwizzle::eA },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageViewCreateFlagBits> ImageViewCreateFlagBitsEntries = {
|
|
{ "FragmentDensityMapDynamicEXT", ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT },
|
|
{ "DescriptorBufferCaptureReplayEXT", ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT },
|
|
{ "FragmentDensityMapDeferredEXT", ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageViewType> ImageViewTypeEntries = {
|
|
{ "1D", ImageViewType::e1D },
|
|
{ "2D", ImageViewType::e2D },
|
|
{ "3D", ImageViewType::e3D },
|
|
{ "Cube", ImageViewType::eCube },
|
|
{ "1DArray", ImageViewType::e1DArray },
|
|
{ "2DArray", ImageViewType::e2DArray },
|
|
{ "CubeArray", ImageViewType::eCubeArray },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ShaderModuleCreateFlagBits> ShaderModuleCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCacheCreateFlagBits> PipelineCacheCreateFlagBitsEntries = {
|
|
{ "ExternallySynchronized", PipelineCacheCreateFlagBits::eExternallySynchronized },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BlendFactor> BlendFactorEntries = {
|
|
{ "Zero", BlendFactor::eZero },
|
|
{ "One", BlendFactor::eOne },
|
|
{ "SrcColor", BlendFactor::eSrcColor },
|
|
{ "OneMinusSrcColor", BlendFactor::eOneMinusSrcColor },
|
|
{ "DstColor", BlendFactor::eDstColor },
|
|
{ "OneMinusDstColor", BlendFactor::eOneMinusDstColor },
|
|
{ "SrcAlpha", BlendFactor::eSrcAlpha },
|
|
{ "OneMinusSrcAlpha", BlendFactor::eOneMinusSrcAlpha },
|
|
{ "DstAlpha", BlendFactor::eDstAlpha },
|
|
{ "OneMinusDstAlpha", BlendFactor::eOneMinusDstAlpha },
|
|
{ "ConstantColor", BlendFactor::eConstantColor },
|
|
{ "OneMinusConstantColor", BlendFactor::eOneMinusConstantColor },
|
|
{ "ConstantAlpha", BlendFactor::eConstantAlpha },
|
|
{ "OneMinusConstantAlpha", BlendFactor::eOneMinusConstantAlpha },
|
|
{ "SrcAlphaSaturate", BlendFactor::eSrcAlphaSaturate },
|
|
{ "Src1Color", BlendFactor::eSrc1Color },
|
|
{ "OneMinusSrc1Color", BlendFactor::eOneMinusSrc1Color },
|
|
{ "Src1Alpha", BlendFactor::eSrc1Alpha },
|
|
{ "OneMinusSrc1Alpha", BlendFactor::eOneMinusSrc1Alpha },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BlendOp> BlendOpEntries = {
|
|
{ "Add", BlendOp::eAdd },
|
|
{ "Subtract", BlendOp::eSubtract },
|
|
{ "ReverseSubtract", BlendOp::eReverseSubtract },
|
|
{ "Min", BlendOp::eMin },
|
|
{ "Max", BlendOp::eMax },
|
|
{ "ZeroEXT", BlendOp::eZeroEXT },
|
|
{ "SrcEXT", BlendOp::eSrcEXT },
|
|
{ "DstEXT", BlendOp::eDstEXT },
|
|
{ "SrcOverEXT", BlendOp::eSrcOverEXT },
|
|
{ "DstOverEXT", BlendOp::eDstOverEXT },
|
|
{ "SrcInEXT", BlendOp::eSrcInEXT },
|
|
{ "DstInEXT", BlendOp::eDstInEXT },
|
|
{ "SrcOutEXT", BlendOp::eSrcOutEXT },
|
|
{ "DstOutEXT", BlendOp::eDstOutEXT },
|
|
{ "SrcAtopEXT", BlendOp::eSrcAtopEXT },
|
|
{ "DstAtopEXT", BlendOp::eDstAtopEXT },
|
|
{ "XorEXT", BlendOp::eXorEXT },
|
|
{ "MultiplyEXT", BlendOp::eMultiplyEXT },
|
|
{ "ScreenEXT", BlendOp::eScreenEXT },
|
|
{ "OverlayEXT", BlendOp::eOverlayEXT },
|
|
{ "DarkenEXT", BlendOp::eDarkenEXT },
|
|
{ "LightenEXT", BlendOp::eLightenEXT },
|
|
{ "ColordodgeEXT", BlendOp::eColordodgeEXT },
|
|
{ "ColorburnEXT", BlendOp::eColorburnEXT },
|
|
{ "HardlightEXT", BlendOp::eHardlightEXT },
|
|
{ "SoftlightEXT", BlendOp::eSoftlightEXT },
|
|
{ "DifferenceEXT", BlendOp::eDifferenceEXT },
|
|
{ "ExclusionEXT", BlendOp::eExclusionEXT },
|
|
{ "InvertEXT", BlendOp::eInvertEXT },
|
|
{ "InvertRgbEXT", BlendOp::eInvertRgbEXT },
|
|
{ "LineardodgeEXT", BlendOp::eLineardodgeEXT },
|
|
{ "LinearburnEXT", BlendOp::eLinearburnEXT },
|
|
{ "VividlightEXT", BlendOp::eVividlightEXT },
|
|
{ "LinearlightEXT", BlendOp::eLinearlightEXT },
|
|
{ "PinlightEXT", BlendOp::ePinlightEXT },
|
|
{ "HardmixEXT", BlendOp::eHardmixEXT },
|
|
{ "HslHueEXT", BlendOp::eHslHueEXT },
|
|
{ "HslSaturationEXT", BlendOp::eHslSaturationEXT },
|
|
{ "HslColorEXT", BlendOp::eHslColorEXT },
|
|
{ "HslLuminosityEXT", BlendOp::eHslLuminosityEXT },
|
|
{ "PlusEXT", BlendOp::ePlusEXT },
|
|
{ "PlusClampedEXT", BlendOp::ePlusClampedEXT },
|
|
{ "PlusClampedAlphaEXT", BlendOp::ePlusClampedAlphaEXT },
|
|
{ "PlusDarkerEXT", BlendOp::ePlusDarkerEXT },
|
|
{ "MinusEXT", BlendOp::eMinusEXT },
|
|
{ "MinusClampedEXT", BlendOp::eMinusClampedEXT },
|
|
{ "ContrastEXT", BlendOp::eContrastEXT },
|
|
{ "InvertOvgEXT", BlendOp::eInvertOvgEXT },
|
|
{ "RedEXT", BlendOp::eRedEXT },
|
|
{ "GreenEXT", BlendOp::eGreenEXT },
|
|
{ "BlueEXT", BlendOp::eBlueEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ColorComponentFlagBits> ColorComponentFlagBitsEntries = {
|
|
{ "R", ColorComponentFlagBits::eR },
|
|
{ "G", ColorComponentFlagBits::eG },
|
|
{ "B", ColorComponentFlagBits::eB },
|
|
{ "A", ColorComponentFlagBits::eA },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CompareOp> CompareOpEntries = {
|
|
{ "Never", CompareOp::eNever },
|
|
{ "Less", CompareOp::eLess },
|
|
{ "Equal", CompareOp::eEqual },
|
|
{ "LessOrEqual", CompareOp::eLessOrEqual },
|
|
{ "Greater", CompareOp::eGreater },
|
|
{ "NotEqual", CompareOp::eNotEqual },
|
|
{ "GreaterOrEqual", CompareOp::eGreaterOrEqual },
|
|
{ "Always", CompareOp::eAlways },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CullModeFlagBits> CullModeFlagBitsEntries = {
|
|
{ "None", CullModeFlagBits::eNone },
|
|
{ "Front", CullModeFlagBits::eFront },
|
|
{ "Back", CullModeFlagBits::eBack },
|
|
{ "FrontAndBack", CullModeFlagBits::eFrontAndBack },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DynamicState> DynamicStateEntries = {
|
|
{ "Viewport", DynamicState::eViewport },
|
|
{ "Scissor", DynamicState::eScissor },
|
|
{ "LineWidth", DynamicState::eLineWidth },
|
|
{ "DepthBias", DynamicState::eDepthBias },
|
|
{ "BlendConstants", DynamicState::eBlendConstants },
|
|
{ "DepthBounds", DynamicState::eDepthBounds },
|
|
{ "StencilCompareMask", DynamicState::eStencilCompareMask },
|
|
{ "StencilWriteMask", DynamicState::eStencilWriteMask },
|
|
{ "StencilReference", DynamicState::eStencilReference },
|
|
{ "CullMode", DynamicState::eCullMode },
|
|
{ "FrontFace", DynamicState::eFrontFace },
|
|
{ "PrimitiveTopology", DynamicState::ePrimitiveTopology },
|
|
{ "ViewportWithCount", DynamicState::eViewportWithCount },
|
|
{ "ScissorWithCount", DynamicState::eScissorWithCount },
|
|
{ "VertexInputBindingStride", DynamicState::eVertexInputBindingStride },
|
|
{ "DepthTestEnable", DynamicState::eDepthTestEnable },
|
|
{ "DepthWriteEnable", DynamicState::eDepthWriteEnable },
|
|
{ "DepthCompareOp", DynamicState::eDepthCompareOp },
|
|
{ "DepthBoundsTestEnable", DynamicState::eDepthBoundsTestEnable },
|
|
{ "StencilTestEnable", DynamicState::eStencilTestEnable },
|
|
{ "StencilOp", DynamicState::eStencilOp },
|
|
{ "RasterizerDiscardEnable", DynamicState::eRasterizerDiscardEnable },
|
|
{ "DepthBiasEnable", DynamicState::eDepthBiasEnable },
|
|
{ "PrimitiveRestartEnable", DynamicState::ePrimitiveRestartEnable },
|
|
{ "ViewportWScalingNV", DynamicState::eViewportWScalingNV },
|
|
{ "DiscardRectangleEXT", DynamicState::eDiscardRectangleEXT },
|
|
{ "DiscardRectangleEnableEXT", DynamicState::eDiscardRectangleEnableEXT },
|
|
{ "DiscardRectangleModeEXT", DynamicState::eDiscardRectangleModeEXT },
|
|
{ "SampleLocationsEXT", DynamicState::eSampleLocationsEXT },
|
|
{ "RayTracingPipelineStackSizeKHR", DynamicState::eRayTracingPipelineStackSizeKHR },
|
|
{ "ViewportShadingRatePaletteNV", DynamicState::eViewportShadingRatePaletteNV },
|
|
{ "ViewportCoarseSampleOrderNV", DynamicState::eViewportCoarseSampleOrderNV },
|
|
{ "ExclusiveScissorEnableNV", DynamicState::eExclusiveScissorEnableNV },
|
|
{ "ExclusiveScissorNV", DynamicState::eExclusiveScissorNV },
|
|
{ "FragmentShadingRateKHR", DynamicState::eFragmentShadingRateKHR },
|
|
{ "LineStippleEXT", DynamicState::eLineStippleEXT },
|
|
{ "VertexInputEXT", DynamicState::eVertexInputEXT },
|
|
{ "PatchControlPointsEXT", DynamicState::ePatchControlPointsEXT },
|
|
{ "LogicOpEXT", DynamicState::eLogicOpEXT },
|
|
{ "ColorWriteEnableEXT", DynamicState::eColorWriteEnableEXT },
|
|
{ "TessellationDomainOriginEXT", DynamicState::eTessellationDomainOriginEXT },
|
|
{ "DepthClampEnableEXT", DynamicState::eDepthClampEnableEXT },
|
|
{ "PolygonModeEXT", DynamicState::ePolygonModeEXT },
|
|
{ "RasterizationSamplesEXT", DynamicState::eRasterizationSamplesEXT },
|
|
{ "SampleMaskEXT", DynamicState::eSampleMaskEXT },
|
|
{ "AlphaToCoverageEnableEXT", DynamicState::eAlphaToCoverageEnableEXT },
|
|
{ "AlphaToOneEnableEXT", DynamicState::eAlphaToOneEnableEXT },
|
|
{ "LogicOpEnableEXT", DynamicState::eLogicOpEnableEXT },
|
|
{ "ColorBlendEnableEXT", DynamicState::eColorBlendEnableEXT },
|
|
{ "ColorBlendEquationEXT", DynamicState::eColorBlendEquationEXT },
|
|
{ "ColorWriteMaskEXT", DynamicState::eColorWriteMaskEXT },
|
|
{ "RasterizationStreamEXT", DynamicState::eRasterizationStreamEXT },
|
|
{ "ConservativeRasterizationModeEXT", DynamicState::eConservativeRasterizationModeEXT },
|
|
{ "ExtraPrimitiveOverestimationSizeEXT", DynamicState::eExtraPrimitiveOverestimationSizeEXT },
|
|
{ "DepthClipEnableEXT", DynamicState::eDepthClipEnableEXT },
|
|
{ "SampleLocationsEnableEXT", DynamicState::eSampleLocationsEnableEXT },
|
|
{ "ColorBlendAdvancedEXT", DynamicState::eColorBlendAdvancedEXT },
|
|
{ "ProvokingVertexModeEXT", DynamicState::eProvokingVertexModeEXT },
|
|
{ "LineRasterizationModeEXT", DynamicState::eLineRasterizationModeEXT },
|
|
{ "LineStippleEnableEXT", DynamicState::eLineStippleEnableEXT },
|
|
{ "DepthClipNegativeOneToOneEXT", DynamicState::eDepthClipNegativeOneToOneEXT },
|
|
{ "ViewportWScalingEnableNV", DynamicState::eViewportWScalingEnableNV },
|
|
{ "ViewportSwizzleNV", DynamicState::eViewportSwizzleNV },
|
|
{ "CoverageToColorEnableNV", DynamicState::eCoverageToColorEnableNV },
|
|
{ "CoverageToColorLocationNV", DynamicState::eCoverageToColorLocationNV },
|
|
{ "CoverageModulationModeNV", DynamicState::eCoverageModulationModeNV },
|
|
{ "CoverageModulationTableEnableNV", DynamicState::eCoverageModulationTableEnableNV },
|
|
{ "CoverageModulationTableNV", DynamicState::eCoverageModulationTableNV },
|
|
{ "ShadingRateImageEnableNV", DynamicState::eShadingRateImageEnableNV },
|
|
{ "RepresentativeFragmentTestEnableNV", DynamicState::eRepresentativeFragmentTestEnableNV },
|
|
{ "CoverageReductionModeNV", DynamicState::eCoverageReductionModeNV },
|
|
{ "AttachmentFeedbackLoopEnableEXT", DynamicState::eAttachmentFeedbackLoopEnableEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FrontFace> FrontFaceEntries = {
|
|
{ "CounterClockwise", FrontFace::eCounterClockwise },
|
|
{ "Clockwise", FrontFace::eClockwise },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, LogicOp> LogicOpEntries = {
|
|
{ "Clear", LogicOp::eClear },
|
|
{ "And", LogicOp::eAnd },
|
|
{ "AndReverse", LogicOp::eAndReverse },
|
|
{ "Copy", LogicOp::eCopy },
|
|
{ "AndInverted", LogicOp::eAndInverted },
|
|
{ "NoOp", LogicOp::eNoOp },
|
|
{ "Xor", LogicOp::eXor },
|
|
{ "Or", LogicOp::eOr },
|
|
{ "Nor", LogicOp::eNor },
|
|
{ "Equivalent", LogicOp::eEquivalent },
|
|
{ "Invert", LogicOp::eInvert },
|
|
{ "OrReverse", LogicOp::eOrReverse },
|
|
{ "CopyInverted", LogicOp::eCopyInverted },
|
|
{ "OrInverted", LogicOp::eOrInverted },
|
|
{ "Nand", LogicOp::eNand },
|
|
{ "Set", LogicOp::eSet },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCreateFlagBits> PipelineCreateFlagBitsEntries = {
|
|
{ "DisableOptimization", PipelineCreateFlagBits::eDisableOptimization },
|
|
{ "AllowDerivatives", PipelineCreateFlagBits::eAllowDerivatives },
|
|
{ "Derivative", PipelineCreateFlagBits::eDerivative },
|
|
{ "ViewIndexFromDeviceIndex", PipelineCreateFlagBits::eViewIndexFromDeviceIndex },
|
|
{ "DispatchBase", PipelineCreateFlagBits::eDispatchBase },
|
|
{ "FailOnPipelineCompileRequired", PipelineCreateFlagBits::eFailOnPipelineCompileRequired },
|
|
{ "EarlyReturnOnFailure", PipelineCreateFlagBits::eEarlyReturnOnFailure },
|
|
{ "RenderingFragmentShadingRateAttachmentKHR", PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR },
|
|
{ "RenderingFragmentDensityMapAttachmentEXT", PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT },
|
|
{ "RayTracingNoNullAnyHitShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR },
|
|
{ "RayTracingNoNullClosestHitShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR },
|
|
{ "RayTracingNoNullMissShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR },
|
|
{ "RayTracingNoNullIntersectionShadersKHR", PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR },
|
|
{ "RayTracingSkipTrianglesKHR", PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR },
|
|
{ "RayTracingSkipAabbsKHR", PipelineCreateFlagBits::eRayTracingSkipAabbsKHR },
|
|
{ "RayTracingShaderGroupHandleCaptureReplayKHR", PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR },
|
|
{ "DeferCompileNV", PipelineCreateFlagBits::eDeferCompileNV },
|
|
{ "CaptureStatisticsKHR", PipelineCreateFlagBits::eCaptureStatisticsKHR },
|
|
{ "CaptureInternalRepresentationsKHR", PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR },
|
|
{ "IndirectBindableNV", PipelineCreateFlagBits::eIndirectBindableNV },
|
|
{ "LibraryKHR", PipelineCreateFlagBits::eLibraryKHR },
|
|
{ "DescriptorBufferEXT", PipelineCreateFlagBits::eDescriptorBufferEXT },
|
|
{ "RetainLinkTimeOptimizationInfoEXT", PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT },
|
|
{ "LinkTimeOptimizationEXT", PipelineCreateFlagBits::eLinkTimeOptimizationEXT },
|
|
{ "RayTracingAllowMotionNV", PipelineCreateFlagBits::eRayTracingAllowMotionNV },
|
|
{ "ColorAttachmentFeedbackLoopEXT", PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT },
|
|
{ "DepthStencilAttachmentFeedbackLoopEXT", PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT },
|
|
{ "RayTracingOpacityMicromapEXT", PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "RayTracingDisplacementMicromapNV", PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "NoProtectedAccessEXT", PipelineCreateFlagBits::eNoProtectedAccessEXT },
|
|
{ "ProtectedAccessOnlyEXT", PipelineCreateFlagBits::eProtectedAccessOnlyEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineShaderStageCreateFlagBits> PipelineShaderStageCreateFlagBitsEntries = {
|
|
{ "AllowVaryingSubgroupSize", PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize },
|
|
{ "RequireFullSubgroups", PipelineShaderStageCreateFlagBits::eRequireFullSubgroups },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PolygonMode> PolygonModeEntries = {
|
|
{ "Fill", PolygonMode::eFill },
|
|
{ "Line", PolygonMode::eLine },
|
|
{ "Point", PolygonMode::ePoint },
|
|
{ "FillRectangleNV", PolygonMode::eFillRectangleNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PrimitiveTopology> PrimitiveTopologyEntries = {
|
|
{ "PointList", PrimitiveTopology::ePointList },
|
|
{ "LineList", PrimitiveTopology::eLineList },
|
|
{ "LineStrip", PrimitiveTopology::eLineStrip },
|
|
{ "TriangleList", PrimitiveTopology::eTriangleList },
|
|
{ "TriangleStrip", PrimitiveTopology::eTriangleStrip },
|
|
{ "TriangleFan", PrimitiveTopology::eTriangleFan },
|
|
{ "LineListWithAdjacency", PrimitiveTopology::eLineListWithAdjacency },
|
|
{ "LineStripWithAdjacency", PrimitiveTopology::eLineStripWithAdjacency },
|
|
{ "TriangleListWithAdjacency", PrimitiveTopology::eTriangleListWithAdjacency },
|
|
{ "TriangleStripWithAdjacency", PrimitiveTopology::eTriangleStripWithAdjacency },
|
|
{ "PatchList", PrimitiveTopology::ePatchList },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ShaderStageFlagBits> ShaderStageFlagBitsEntries = {
|
|
{ "Vertex", ShaderStageFlagBits::eVertex },
|
|
{ "TessellationControl", ShaderStageFlagBits::eTessellationControl },
|
|
{ "TessellationEvaluation", ShaderStageFlagBits::eTessellationEvaluation },
|
|
{ "Geometry", ShaderStageFlagBits::eGeometry },
|
|
{ "Fragment", ShaderStageFlagBits::eFragment },
|
|
{ "Compute", ShaderStageFlagBits::eCompute },
|
|
{ "AllGraphics", ShaderStageFlagBits::eAllGraphics },
|
|
{ "All", ShaderStageFlagBits::eAll },
|
|
{ "RaygenKHR", ShaderStageFlagBits::eRaygenKHR },
|
|
{ "AnyHitKHR", ShaderStageFlagBits::eAnyHitKHR },
|
|
{ "ClosestHitKHR", ShaderStageFlagBits::eClosestHitKHR },
|
|
{ "MissKHR", ShaderStageFlagBits::eMissKHR },
|
|
{ "IntersectionKHR", ShaderStageFlagBits::eIntersectionKHR },
|
|
{ "CallableKHR", ShaderStageFlagBits::eCallableKHR },
|
|
{ "TaskEXT", ShaderStageFlagBits::eTaskEXT },
|
|
{ "MeshEXT", ShaderStageFlagBits::eMeshEXT },
|
|
{ "SubpassShadingHUAWEI", ShaderStageFlagBits::eSubpassShadingHUAWEI },
|
|
{ "ClusterCullingHUAWEI", ShaderStageFlagBits::eClusterCullingHUAWEI },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, StencilOp> StencilOpEntries = {
|
|
{ "Keep", StencilOp::eKeep },
|
|
{ "Zero", StencilOp::eZero },
|
|
{ "Replace", StencilOp::eReplace },
|
|
{ "IncrementAndClamp", StencilOp::eIncrementAndClamp },
|
|
{ "DecrementAndClamp", StencilOp::eDecrementAndClamp },
|
|
{ "Invert", StencilOp::eInvert },
|
|
{ "IncrementAndWrap", StencilOp::eIncrementAndWrap },
|
|
{ "DecrementAndWrap", StencilOp::eDecrementAndWrap },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VertexInputRate> VertexInputRateEntries = {
|
|
{ "Vertex", VertexInputRate::eVertex },
|
|
{ "Instance", VertexInputRate::eInstance },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineColorBlendStateCreateFlagBits> PipelineColorBlendStateCreateFlagBitsEntries = {
|
|
{ "RasterizationOrderAttachmentAccessEXT", PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineDepthStencilStateCreateFlagBits> PipelineDepthStencilStateCreateFlagBitsEntries = {
|
|
{ "RasterizationOrderAttachmentDepthAccessEXT", PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT },
|
|
{ "RasterizationOrderAttachmentStencilAccessEXT", PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineDynamicStateCreateFlagBits> PipelineDynamicStateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineInputAssemblyStateCreateFlagBits> PipelineInputAssemblyStateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineLayoutCreateFlagBits> PipelineLayoutCreateFlagBitsEntries = {
|
|
{ "IndependentSetsEXT", PipelineLayoutCreateFlagBits::eIndependentSetsEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineMultisampleStateCreateFlagBits> PipelineMultisampleStateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationStateCreateFlagBits> PipelineRasterizationStateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineTessellationStateCreateFlagBits> PipelineTessellationStateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineVertexInputStateCreateFlagBits> PipelineVertexInputStateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineViewportStateCreateFlagBits> PipelineViewportStateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BorderColor> BorderColorEntries = {
|
|
{ "FloatTransparentBlack", BorderColor::eFloatTransparentBlack },
|
|
{ "IntTransparentBlack", BorderColor::eIntTransparentBlack },
|
|
{ "FloatOpaqueBlack", BorderColor::eFloatOpaqueBlack },
|
|
{ "IntOpaqueBlack", BorderColor::eIntOpaqueBlack },
|
|
{ "FloatOpaqueWhite", BorderColor::eFloatOpaqueWhite },
|
|
{ "IntOpaqueWhite", BorderColor::eIntOpaqueWhite },
|
|
{ "FloatCustomEXT", BorderColor::eFloatCustomEXT },
|
|
{ "IntCustomEXT", BorderColor::eIntCustomEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, Filter> FilterEntries = {
|
|
{ "Nearest", Filter::eNearest },
|
|
{ "Linear", Filter::eLinear },
|
|
{ "CubicEXT", Filter::eCubicEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerAddressMode> SamplerAddressModeEntries = {
|
|
{ "Repeat", SamplerAddressMode::eRepeat },
|
|
{ "MirroredRepeat", SamplerAddressMode::eMirroredRepeat },
|
|
{ "ClampToEdge", SamplerAddressMode::eClampToEdge },
|
|
{ "ClampToBorder", SamplerAddressMode::eClampToBorder },
|
|
{ "MirrorClampToEdge", SamplerAddressMode::eMirrorClampToEdge },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerCreateFlagBits> SamplerCreateFlagBitsEntries = {
|
|
{ "SubsampledEXT", SamplerCreateFlagBits::eSubsampledEXT },
|
|
{ "SubsampledCoarseReconstructionEXT", SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT },
|
|
{ "DescriptorBufferCaptureReplayEXT", SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT },
|
|
{ "NonSeamlessCubeMapEXT", SamplerCreateFlagBits::eNonSeamlessCubeMapEXT },
|
|
{ "ImageProcessingQCOM", SamplerCreateFlagBits::eImageProcessingQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerMipmapMode> SamplerMipmapModeEntries = {
|
|
{ "Nearest", SamplerMipmapMode::eNearest },
|
|
{ "Linear", SamplerMipmapMode::eLinear },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorPoolCreateFlagBits> DescriptorPoolCreateFlagBitsEntries = {
|
|
{ "FreeDescriptorSet", DescriptorPoolCreateFlagBits::eFreeDescriptorSet },
|
|
{ "UpdateAfterBind", DescriptorPoolCreateFlagBits::eUpdateAfterBind },
|
|
{ "HostOnlyEXT", DescriptorPoolCreateFlagBits::eHostOnlyEXT },
|
|
{ "AllowOverallocationSetsNV", DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV },
|
|
{ "AllowOverallocationPoolsNV", DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorSetLayoutCreateFlagBits> DescriptorSetLayoutCreateFlagBitsEntries = {
|
|
{ "UpdateAfterBindPool", DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool },
|
|
{ "PushDescriptorKHR", DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR },
|
|
{ "DescriptorBufferEXT", DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT },
|
|
{ "EmbeddedImmutableSamplersEXT", DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT },
|
|
{ "IndirectBindableNV", DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV },
|
|
{ "HostOnlyPoolEXT", DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorType> DescriptorTypeEntries = {
|
|
{ "Sampler", DescriptorType::eSampler },
|
|
{ "CombinedImageSampler", DescriptorType::eCombinedImageSampler },
|
|
{ "SampledImage", DescriptorType::eSampledImage },
|
|
{ "StorageImage", DescriptorType::eStorageImage },
|
|
{ "UniformTexelBuffer", DescriptorType::eUniformTexelBuffer },
|
|
{ "StorageTexelBuffer", DescriptorType::eStorageTexelBuffer },
|
|
{ "UniformBuffer", DescriptorType::eUniformBuffer },
|
|
{ "StorageBuffer", DescriptorType::eStorageBuffer },
|
|
{ "UniformBufferDynamic", DescriptorType::eUniformBufferDynamic },
|
|
{ "StorageBufferDynamic", DescriptorType::eStorageBufferDynamic },
|
|
{ "InputAttachment", DescriptorType::eInputAttachment },
|
|
{ "InlineUniformBlock", DescriptorType::eInlineUniformBlock },
|
|
{ "AccelerationStructureKHR", DescriptorType::eAccelerationStructureKHR },
|
|
{ "AccelerationStructureNV", DescriptorType::eAccelerationStructureNV },
|
|
{ "SampleWeightImageQCOM", DescriptorType::eSampleWeightImageQCOM },
|
|
{ "BlockMatchImageQCOM", DescriptorType::eBlockMatchImageQCOM },
|
|
{ "MutableEXT", DescriptorType::eMutableEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorPoolResetFlagBits> DescriptorPoolResetFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccessFlagBits> AccessFlagBitsEntries = {
|
|
{ "IndirectCommandRead", AccessFlagBits::eIndirectCommandRead },
|
|
{ "IndexRead", AccessFlagBits::eIndexRead },
|
|
{ "VertexAttributeRead", AccessFlagBits::eVertexAttributeRead },
|
|
{ "UniformRead", AccessFlagBits::eUniformRead },
|
|
{ "InputAttachmentRead", AccessFlagBits::eInputAttachmentRead },
|
|
{ "ShaderRead", AccessFlagBits::eShaderRead },
|
|
{ "ShaderWrite", AccessFlagBits::eShaderWrite },
|
|
{ "ColorAttachmentRead", AccessFlagBits::eColorAttachmentRead },
|
|
{ "ColorAttachmentWrite", AccessFlagBits::eColorAttachmentWrite },
|
|
{ "DepthStencilAttachmentRead", AccessFlagBits::eDepthStencilAttachmentRead },
|
|
{ "DepthStencilAttachmentWrite", AccessFlagBits::eDepthStencilAttachmentWrite },
|
|
{ "TransferRead", AccessFlagBits::eTransferRead },
|
|
{ "TransferWrite", AccessFlagBits::eTransferWrite },
|
|
{ "HostRead", AccessFlagBits::eHostRead },
|
|
{ "HostWrite", AccessFlagBits::eHostWrite },
|
|
{ "MemoryRead", AccessFlagBits::eMemoryRead },
|
|
{ "MemoryWrite", AccessFlagBits::eMemoryWrite },
|
|
{ "None", AccessFlagBits::eNone },
|
|
{ "TransformFeedbackWriteEXT", AccessFlagBits::eTransformFeedbackWriteEXT },
|
|
{ "TransformFeedbackCounterReadEXT", AccessFlagBits::eTransformFeedbackCounterReadEXT },
|
|
{ "TransformFeedbackCounterWriteEXT", AccessFlagBits::eTransformFeedbackCounterWriteEXT },
|
|
{ "ConditionalRenderingReadEXT", AccessFlagBits::eConditionalRenderingReadEXT },
|
|
{ "ColorAttachmentReadNoncoherentEXT", AccessFlagBits::eColorAttachmentReadNoncoherentEXT },
|
|
{ "AccelerationStructureReadKHR", AccessFlagBits::eAccelerationStructureReadKHR },
|
|
{ "AccelerationStructureWriteKHR", AccessFlagBits::eAccelerationStructureWriteKHR },
|
|
{ "FragmentDensityMapReadEXT", AccessFlagBits::eFragmentDensityMapReadEXT },
|
|
{ "FragmentShadingRateAttachmentReadKHR", AccessFlagBits::eFragmentShadingRateAttachmentReadKHR },
|
|
{ "CommandPreprocessReadNV", AccessFlagBits::eCommandPreprocessReadNV },
|
|
{ "CommandPreprocessWriteNV", AccessFlagBits::eCommandPreprocessWriteNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AttachmentDescriptionFlagBits> AttachmentDescriptionFlagBitsEntries = {
|
|
{ "MayAlias", AttachmentDescriptionFlagBits::eMayAlias },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AttachmentLoadOp> AttachmentLoadOpEntries = {
|
|
{ "Load", AttachmentLoadOp::eLoad },
|
|
{ "Clear", AttachmentLoadOp::eClear },
|
|
{ "DontCare", AttachmentLoadOp::eDontCare },
|
|
{ "NoneEXT", AttachmentLoadOp::eNoneEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AttachmentStoreOp> AttachmentStoreOpEntries = {
|
|
{ "Store", AttachmentStoreOp::eStore },
|
|
{ "DontCare", AttachmentStoreOp::eDontCare },
|
|
{ "None", AttachmentStoreOp::eNone },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DependencyFlagBits> DependencyFlagBitsEntries = {
|
|
{ "ByRegion", DependencyFlagBits::eByRegion },
|
|
{ "DeviceGroup", DependencyFlagBits::eDeviceGroup },
|
|
{ "ViewLocal", DependencyFlagBits::eViewLocal },
|
|
{ "FeedbackLoopEXT", DependencyFlagBits::eFeedbackLoopEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FramebufferCreateFlagBits> FramebufferCreateFlagBitsEntries = {
|
|
{ "Imageless", FramebufferCreateFlagBits::eImageless },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineBindPoint> PipelineBindPointEntries = {
|
|
{ "Graphics", PipelineBindPoint::eGraphics },
|
|
{ "Compute", PipelineBindPoint::eCompute },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "ExecutionGraphAMDX", PipelineBindPoint::eExecutionGraphAMDX },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "RayTracingKHR", PipelineBindPoint::eRayTracingKHR },
|
|
{ "SubpassShadingHUAWEI", PipelineBindPoint::eSubpassShadingHUAWEI },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, RenderPassCreateFlagBits> RenderPassCreateFlagBitsEntries = {
|
|
{ "TransformQCOM", RenderPassCreateFlagBits::eTransformQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SubpassDescriptionFlagBits> SubpassDescriptionFlagBitsEntries = {
|
|
{ "PerViewAttributesNVX", SubpassDescriptionFlagBits::ePerViewAttributesNVX },
|
|
{ "PerViewPositionXOnlyNVX", SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX },
|
|
{ "FragmentRegionQCOM", SubpassDescriptionFlagBits::eFragmentRegionQCOM },
|
|
{ "ShaderResolveQCOM", SubpassDescriptionFlagBits::eShaderResolveQCOM },
|
|
{ "RasterizationOrderAttachmentColorAccessEXT", SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT },
|
|
{ "RasterizationOrderAttachmentDepthAccessEXT", SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT },
|
|
{ "RasterizationOrderAttachmentStencilAccessEXT", SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT },
|
|
{ "EnableLegacyDitheringEXT", SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandPoolCreateFlagBits> CommandPoolCreateFlagBitsEntries = {
|
|
{ "Transient", CommandPoolCreateFlagBits::eTransient },
|
|
{ "ResetCommandBuffer", CommandPoolCreateFlagBits::eResetCommandBuffer },
|
|
{ "Protected", CommandPoolCreateFlagBits::eProtected },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandPoolResetFlagBits> CommandPoolResetFlagBitsEntries = {
|
|
{ "ReleaseResources", CommandPoolResetFlagBits::eReleaseResources },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandBufferLevel> CommandBufferLevelEntries = {
|
|
{ "Primary", CommandBufferLevel::ePrimary },
|
|
{ "Secondary", CommandBufferLevel::eSecondary },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandBufferResetFlagBits> CommandBufferResetFlagBitsEntries = {
|
|
{ "ReleaseResources", CommandBufferResetFlagBits::eReleaseResources },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandBufferUsageFlagBits> CommandBufferUsageFlagBitsEntries = {
|
|
{ "OneTimeSubmit", CommandBufferUsageFlagBits::eOneTimeSubmit },
|
|
{ "RenderPassContinue", CommandBufferUsageFlagBits::eRenderPassContinue },
|
|
{ "SimultaneousUse", CommandBufferUsageFlagBits::eSimultaneousUse },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryControlFlagBits> QueryControlFlagBitsEntries = {
|
|
{ "Precise", QueryControlFlagBits::ePrecise },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, IndexType> IndexTypeEntries = {
|
|
{ "Uint16", IndexType::eUint16 },
|
|
{ "Uint32", IndexType::eUint32 },
|
|
{ "NoneKHR", IndexType::eNoneKHR },
|
|
{ "Uint8EXT", IndexType::eUint8EXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, StencilFaceFlagBits> StencilFaceFlagBitsEntries = {
|
|
{ "Front", StencilFaceFlagBits::eFront },
|
|
{ "Back", StencilFaceFlagBits::eBack },
|
|
{ "FrontAndBack", StencilFaceFlagBits::eFrontAndBack },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SubpassContents> SubpassContentsEntries = {
|
|
{ "Inline", SubpassContents::eInline },
|
|
{ "SecondaryCommandBuffers", SubpassContents::eSecondaryCommandBuffers },
|
|
{ "InlineAndSecondaryCommandBuffersEXT", SubpassContents::eInlineAndSecondaryCommandBuffersEXT },
|
|
|
|
};
|
|
|
|
//=== VK_VERSION_1_1 ===
|
|
|
|
std::unordered_map<std::string, SubgroupFeatureFlagBits> SubgroupFeatureFlagBitsEntries = {
|
|
{ "Basic", SubgroupFeatureFlagBits::eBasic },
|
|
{ "Vote", SubgroupFeatureFlagBits::eVote },
|
|
{ "Arithmetic", SubgroupFeatureFlagBits::eArithmetic },
|
|
{ "Ballot", SubgroupFeatureFlagBits::eBallot },
|
|
{ "Shuffle", SubgroupFeatureFlagBits::eShuffle },
|
|
{ "ShuffleRelative", SubgroupFeatureFlagBits::eShuffleRelative },
|
|
{ "Clustered", SubgroupFeatureFlagBits::eClustered },
|
|
{ "Quad", SubgroupFeatureFlagBits::eQuad },
|
|
{ "PartitionedNV", SubgroupFeatureFlagBits::ePartitionedNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PeerMemoryFeatureFlagBits> PeerMemoryFeatureFlagBitsEntries = {
|
|
{ "CopySrc", PeerMemoryFeatureFlagBits::eCopySrc },
|
|
{ "CopyDst", PeerMemoryFeatureFlagBits::eCopyDst },
|
|
{ "GenericSrc", PeerMemoryFeatureFlagBits::eGenericSrc },
|
|
{ "GenericDst", PeerMemoryFeatureFlagBits::eGenericDst },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MemoryAllocateFlagBits> MemoryAllocateFlagBitsEntries = {
|
|
{ "DeviceMask", MemoryAllocateFlagBits::eDeviceMask },
|
|
{ "DeviceAddress", MemoryAllocateFlagBits::eDeviceAddress },
|
|
{ "DeviceAddressCaptureReplay", MemoryAllocateFlagBits::eDeviceAddressCaptureReplay },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandPoolTrimFlagBits> CommandPoolTrimFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PointClippingBehavior> PointClippingBehaviorEntries = {
|
|
{ "AllClipPlanes", PointClippingBehavior::eAllClipPlanes },
|
|
{ "UserClipPlanesOnly", PointClippingBehavior::eUserClipPlanesOnly },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, TessellationDomainOrigin> TessellationDomainOriginEntries = {
|
|
{ "UpperLeft", TessellationDomainOrigin::eUpperLeft },
|
|
{ "LowerLeft", TessellationDomainOrigin::eLowerLeft },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerYcbcrModelConversion> SamplerYcbcrModelConversionEntries = {
|
|
{ "RgbIdentity", SamplerYcbcrModelConversion::eRgbIdentity }, { "YcbcrIdentity", SamplerYcbcrModelConversion::eYcbcrIdentity },
|
|
{ "Ycbcr709", SamplerYcbcrModelConversion::eYcbcr709 }, { "Ycbcr601", SamplerYcbcrModelConversion::eYcbcr601 },
|
|
{ "Ycbcr2020", SamplerYcbcrModelConversion::eYcbcr2020 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerYcbcrRange> SamplerYcbcrRangeEntries = {
|
|
{ "ItuFull", SamplerYcbcrRange::eItuFull },
|
|
{ "ItuNarrow", SamplerYcbcrRange::eItuNarrow },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ChromaLocation> ChromaLocationEntries = {
|
|
{ "CositedEven", ChromaLocation::eCositedEven },
|
|
{ "Midpoint", ChromaLocation::eMidpoint },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorUpdateTemplateType> DescriptorUpdateTemplateTypeEntries = {
|
|
{ "DescriptorSet", DescriptorUpdateTemplateType::eDescriptorSet },
|
|
{ "PushDescriptorsKHR", DescriptorUpdateTemplateType::ePushDescriptorsKHR },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorUpdateTemplateCreateFlagBits> DescriptorUpdateTemplateCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalMemoryHandleTypeFlagBits> ExternalMemoryHandleTypeFlagBitsEntries = {
|
|
{ "OpaqueFd", ExternalMemoryHandleTypeFlagBits::eOpaqueFd },
|
|
{ "OpaqueWin32", ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 },
|
|
{ "OpaqueWin32Kmt", ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt },
|
|
{ "D3D11Texture", ExternalMemoryHandleTypeFlagBits::eD3D11Texture },
|
|
{ "D3D11TextureKmt", ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt },
|
|
{ "D3D12Heap", ExternalMemoryHandleTypeFlagBits::eD3D12Heap },
|
|
{ "D3D12Resource", ExternalMemoryHandleTypeFlagBits::eD3D12Resource },
|
|
{ "DmaBufEXT", ExternalMemoryHandleTypeFlagBits::eDmaBufEXT },
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
{ "AndroidHardwareBufferANDROID", ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID },
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
{ "HostAllocationEXT", ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT },
|
|
{ "HostMappedForeignMemoryEXT", ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT },
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
{ "ZirconVmoFUCHSIA", ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA },
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
{ "RdmaAddressNV", ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV },
|
|
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
{ "ScreenBufferQNX", ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX },
|
|
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalMemoryFeatureFlagBits> ExternalMemoryFeatureFlagBitsEntries = {
|
|
{ "DedicatedOnly", ExternalMemoryFeatureFlagBits::eDedicatedOnly },
|
|
{ "Exportable", ExternalMemoryFeatureFlagBits::eExportable },
|
|
{ "Importable", ExternalMemoryFeatureFlagBits::eImportable },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalFenceHandleTypeFlagBits> ExternalFenceHandleTypeFlagBitsEntries = {
|
|
{ "OpaqueFd", ExternalFenceHandleTypeFlagBits::eOpaqueFd },
|
|
{ "OpaqueWin32", ExternalFenceHandleTypeFlagBits::eOpaqueWin32 },
|
|
{ "OpaqueWin32Kmt", ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt },
|
|
{ "SyncFd", ExternalFenceHandleTypeFlagBits::eSyncFd },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalFenceFeatureFlagBits> ExternalFenceFeatureFlagBitsEntries = {
|
|
{ "Exportable", ExternalFenceFeatureFlagBits::eExportable },
|
|
{ "Importable", ExternalFenceFeatureFlagBits::eImportable },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FenceImportFlagBits> FenceImportFlagBitsEntries = {
|
|
{ "Temporary", FenceImportFlagBits::eTemporary },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreImportFlagBits> SemaphoreImportFlagBitsEntries = {
|
|
{ "Temporary", SemaphoreImportFlagBits::eTemporary },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalSemaphoreHandleTypeFlagBits> ExternalSemaphoreHandleTypeFlagBitsEntries = {
|
|
{ "OpaqueFd", ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd },
|
|
{ "OpaqueWin32", ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 },
|
|
{ "OpaqueWin32Kmt", ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt },
|
|
{ "D3D12Fence", ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence },
|
|
{ "SyncFd", ExternalSemaphoreHandleTypeFlagBits::eSyncFd },
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
{ "ZirconEventFUCHSIA", ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA },
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalSemaphoreFeatureFlagBits> ExternalSemaphoreFeatureFlagBitsEntries = {
|
|
{ "Exportable", ExternalSemaphoreFeatureFlagBits::eExportable },
|
|
{ "Importable", ExternalSemaphoreFeatureFlagBits::eImportable },
|
|
|
|
};
|
|
|
|
//=== VK_VERSION_1_2 ===
|
|
|
|
std::unordered_map<std::string, DriverId> DriverIdEntries = {
|
|
{ "AmdProprietary", DriverId::eAmdProprietary },
|
|
{ "AmdOpenSource", DriverId::eAmdOpenSource },
|
|
{ "MesaRadv", DriverId::eMesaRadv },
|
|
{ "NvidiaProprietary", DriverId::eNvidiaProprietary },
|
|
{ "IntelProprietaryWindows", DriverId::eIntelProprietaryWindows },
|
|
{ "IntelOpenSourceMESA", DriverId::eIntelOpenSourceMESA },
|
|
{ "ImaginationProprietary", DriverId::eImaginationProprietary },
|
|
{ "QualcommProprietary", DriverId::eQualcommProprietary },
|
|
{ "ArmProprietary", DriverId::eArmProprietary },
|
|
{ "GoogleSwiftshader", DriverId::eGoogleSwiftshader },
|
|
{ "GgpProprietary", DriverId::eGgpProprietary },
|
|
{ "BroadcomProprietary", DriverId::eBroadcomProprietary },
|
|
{ "MesaLlvmpipe", DriverId::eMesaLlvmpipe },
|
|
{ "Moltenvk", DriverId::eMoltenvk },
|
|
{ "CoreaviProprietary", DriverId::eCoreaviProprietary },
|
|
{ "JuiceProprietary", DriverId::eJuiceProprietary },
|
|
{ "VerisiliconProprietary", DriverId::eVerisiliconProprietary },
|
|
{ "MesaTurnip", DriverId::eMesaTurnip },
|
|
{ "MesaV3Dv", DriverId::eMesaV3Dv },
|
|
{ "MesaPanvk", DriverId::eMesaPanvk },
|
|
{ "SamsungProprietary", DriverId::eSamsungProprietary },
|
|
{ "MesaVenus", DriverId::eMesaVenus },
|
|
{ "MesaDozen", DriverId::eMesaDozen },
|
|
{ "MesaNvk", DriverId::eMesaNvk },
|
|
{ "ImaginationOpenSourceMESA", DriverId::eImaginationOpenSourceMESA },
|
|
{ "MesaAgxv", DriverId::eMesaAgxv },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ShaderFloatControlsIndependence> ShaderFloatControlsIndependenceEntries = {
|
|
{ "32BitOnly", ShaderFloatControlsIndependence::e32BitOnly },
|
|
{ "All", ShaderFloatControlsIndependence::eAll },
|
|
{ "None", ShaderFloatControlsIndependence::eNone },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorBindingFlagBits> DescriptorBindingFlagBitsEntries = {
|
|
{ "UpdateAfterBind", DescriptorBindingFlagBits::eUpdateAfterBind },
|
|
{ "UpdateUnusedWhilePending", DescriptorBindingFlagBits::eUpdateUnusedWhilePending },
|
|
{ "PartiallyBound", DescriptorBindingFlagBits::ePartiallyBound },
|
|
{ "VariableDescriptorCount", DescriptorBindingFlagBits::eVariableDescriptorCount },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ResolveModeFlagBits> ResolveModeFlagBitsEntries = {
|
|
{ "None", ResolveModeFlagBits::eNone },
|
|
{ "SampleZero", ResolveModeFlagBits::eSampleZero },
|
|
{ "Average", ResolveModeFlagBits::eAverage },
|
|
{ "Min", ResolveModeFlagBits::eMin },
|
|
{ "Max", ResolveModeFlagBits::eMax },
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
{ "ExternalFormatDownsampleANDROID", ResolveModeFlagBits::eExternalFormatDownsampleANDROID },
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerReductionMode> SamplerReductionModeEntries = {
|
|
{ "WeightedAverage", SamplerReductionMode::eWeightedAverage },
|
|
{ "Min", SamplerReductionMode::eMin },
|
|
{ "Max", SamplerReductionMode::eMax },
|
|
{ "WeightedAverageRangeclampQCOM", SamplerReductionMode::eWeightedAverageRangeclampQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreType> SemaphoreTypeEntries = {
|
|
{ "Binary", SemaphoreType::eBinary },
|
|
{ "Timeline", SemaphoreType::eTimeline },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreWaitFlagBits> SemaphoreWaitFlagBitsEntries = {
|
|
{ "Any", SemaphoreWaitFlagBits::eAny },
|
|
|
|
};
|
|
|
|
//=== VK_VERSION_1_3 ===
|
|
|
|
std::unordered_map<std::string, PipelineCreationFeedbackFlagBits> PipelineCreationFeedbackFlagBitsEntries = {
|
|
{ "Valid", PipelineCreationFeedbackFlagBits::eValid },
|
|
{ "ApplicationPipelineCacheHit", PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit },
|
|
{ "BasePipelineAcceleration", PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ToolPurposeFlagBits> ToolPurposeFlagBitsEntries = {
|
|
{ "Validation", ToolPurposeFlagBits::eValidation },
|
|
{ "Profiling", ToolPurposeFlagBits::eProfiling },
|
|
{ "Tracing", ToolPurposeFlagBits::eTracing },
|
|
{ "AdditionalFeatures", ToolPurposeFlagBits::eAdditionalFeatures },
|
|
{ "ModifyingFeatures", ToolPurposeFlagBits::eModifyingFeatures },
|
|
{ "DebugReportingEXT", ToolPurposeFlagBits::eDebugReportingEXT },
|
|
{ "DebugMarkersEXT", ToolPurposeFlagBits::eDebugMarkersEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PrivateDataSlotCreateFlagBits> PrivateDataSlotCreateFlagBitsEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineStageFlagBits2> PipelineStageFlagBits2Entries = {
|
|
{ "None", PipelineStageFlagBits2::eNone },
|
|
{ "TopOfPipe", PipelineStageFlagBits2::eTopOfPipe },
|
|
{ "DrawIndirect", PipelineStageFlagBits2::eDrawIndirect },
|
|
{ "VertexInput", PipelineStageFlagBits2::eVertexInput },
|
|
{ "VertexShader", PipelineStageFlagBits2::eVertexShader },
|
|
{ "TessellationControlShader", PipelineStageFlagBits2::eTessellationControlShader },
|
|
{ "TessellationEvaluationShader", PipelineStageFlagBits2::eTessellationEvaluationShader },
|
|
{ "GeometryShader", PipelineStageFlagBits2::eGeometryShader },
|
|
{ "FragmentShader", PipelineStageFlagBits2::eFragmentShader },
|
|
{ "EarlyFragmentTests", PipelineStageFlagBits2::eEarlyFragmentTests },
|
|
{ "LateFragmentTests", PipelineStageFlagBits2::eLateFragmentTests },
|
|
{ "ColorAttachmentOutput", PipelineStageFlagBits2::eColorAttachmentOutput },
|
|
{ "ComputeShader", PipelineStageFlagBits2::eComputeShader },
|
|
{ "AllTransfer", PipelineStageFlagBits2::eAllTransfer },
|
|
{ "BottomOfPipe", PipelineStageFlagBits2::eBottomOfPipe },
|
|
{ "Host", PipelineStageFlagBits2::eHost },
|
|
{ "AllGraphics", PipelineStageFlagBits2::eAllGraphics },
|
|
{ "AllCommands", PipelineStageFlagBits2::eAllCommands },
|
|
{ "Copy", PipelineStageFlagBits2::eCopy },
|
|
{ "Resolve", PipelineStageFlagBits2::eResolve },
|
|
{ "Blit", PipelineStageFlagBits2::eBlit },
|
|
{ "Clear", PipelineStageFlagBits2::eClear },
|
|
{ "IndexInput", PipelineStageFlagBits2::eIndexInput },
|
|
{ "VertexAttributeInput", PipelineStageFlagBits2::eVertexAttributeInput },
|
|
{ "PreRasterizationShaders", PipelineStageFlagBits2::ePreRasterizationShaders },
|
|
{ "VideoDecodeKHR", PipelineStageFlagBits2::eVideoDecodeKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeKHR", PipelineStageFlagBits2::eVideoEncodeKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "TransformFeedbackEXT", PipelineStageFlagBits2::eTransformFeedbackEXT },
|
|
{ "ConditionalRenderingEXT", PipelineStageFlagBits2::eConditionalRenderingEXT },
|
|
{ "CommandPreprocessNV", PipelineStageFlagBits2::eCommandPreprocessNV },
|
|
{ "FragmentShadingRateAttachmentKHR", PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR },
|
|
{ "AccelerationStructureBuildKHR", PipelineStageFlagBits2::eAccelerationStructureBuildKHR },
|
|
{ "RayTracingShaderKHR", PipelineStageFlagBits2::eRayTracingShaderKHR },
|
|
{ "FragmentDensityProcessEXT", PipelineStageFlagBits2::eFragmentDensityProcessEXT },
|
|
{ "TaskShaderEXT", PipelineStageFlagBits2::eTaskShaderEXT },
|
|
{ "MeshShaderEXT", PipelineStageFlagBits2::eMeshShaderEXT },
|
|
{ "SubpassShaderHUAWEI", PipelineStageFlagBits2::eSubpassShaderHUAWEI },
|
|
{ "InvocationMaskHUAWEI", PipelineStageFlagBits2::eInvocationMaskHUAWEI },
|
|
{ "AccelerationStructureCopyKHR", PipelineStageFlagBits2::eAccelerationStructureCopyKHR },
|
|
{ "MicromapBuildEXT", PipelineStageFlagBits2::eMicromapBuildEXT },
|
|
{ "ClusterCullingShaderHUAWEI", PipelineStageFlagBits2::eClusterCullingShaderHUAWEI },
|
|
{ "OpticalFlowNV", PipelineStageFlagBits2::eOpticalFlowNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccessFlagBits2> AccessFlagBits2Entries = {
|
|
{ "None", AccessFlagBits2::eNone },
|
|
{ "IndirectCommandRead", AccessFlagBits2::eIndirectCommandRead },
|
|
{ "IndexRead", AccessFlagBits2::eIndexRead },
|
|
{ "VertexAttributeRead", AccessFlagBits2::eVertexAttributeRead },
|
|
{ "UniformRead", AccessFlagBits2::eUniformRead },
|
|
{ "InputAttachmentRead", AccessFlagBits2::eInputAttachmentRead },
|
|
{ "ShaderRead", AccessFlagBits2::eShaderRead },
|
|
{ "ShaderWrite", AccessFlagBits2::eShaderWrite },
|
|
{ "ColorAttachmentRead", AccessFlagBits2::eColorAttachmentRead },
|
|
{ "ColorAttachmentWrite", AccessFlagBits2::eColorAttachmentWrite },
|
|
{ "DepthStencilAttachmentRead", AccessFlagBits2::eDepthStencilAttachmentRead },
|
|
{ "DepthStencilAttachmentWrite", AccessFlagBits2::eDepthStencilAttachmentWrite },
|
|
{ "TransferRead", AccessFlagBits2::eTransferRead },
|
|
{ "TransferWrite", AccessFlagBits2::eTransferWrite },
|
|
{ "HostRead", AccessFlagBits2::eHostRead },
|
|
{ "HostWrite", AccessFlagBits2::eHostWrite },
|
|
{ "MemoryRead", AccessFlagBits2::eMemoryRead },
|
|
{ "MemoryWrite", AccessFlagBits2::eMemoryWrite },
|
|
{ "ShaderSampledRead", AccessFlagBits2::eShaderSampledRead },
|
|
{ "ShaderStorageRead", AccessFlagBits2::eShaderStorageRead },
|
|
{ "ShaderStorageWrite", AccessFlagBits2::eShaderStorageWrite },
|
|
{ "VideoDecodeReadKHR", AccessFlagBits2::eVideoDecodeReadKHR },
|
|
{ "VideoDecodeWriteKHR", AccessFlagBits2::eVideoDecodeWriteKHR },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeReadKHR", AccessFlagBits2::eVideoEncodeReadKHR },
|
|
{ "VideoEncodeWriteKHR", AccessFlagBits2::eVideoEncodeWriteKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "TransformFeedbackWriteEXT", AccessFlagBits2::eTransformFeedbackWriteEXT },
|
|
{ "TransformFeedbackCounterReadEXT", AccessFlagBits2::eTransformFeedbackCounterReadEXT },
|
|
{ "TransformFeedbackCounterWriteEXT", AccessFlagBits2::eTransformFeedbackCounterWriteEXT },
|
|
{ "ConditionalRenderingReadEXT", AccessFlagBits2::eConditionalRenderingReadEXT },
|
|
{ "CommandPreprocessReadNV", AccessFlagBits2::eCommandPreprocessReadNV },
|
|
{ "CommandPreprocessWriteNV", AccessFlagBits2::eCommandPreprocessWriteNV },
|
|
{ "FragmentShadingRateAttachmentReadKHR", AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR },
|
|
{ "AccelerationStructureReadKHR", AccessFlagBits2::eAccelerationStructureReadKHR },
|
|
{ "AccelerationStructureWriteKHR", AccessFlagBits2::eAccelerationStructureWriteKHR },
|
|
{ "FragmentDensityMapReadEXT", AccessFlagBits2::eFragmentDensityMapReadEXT },
|
|
{ "ColorAttachmentReadNoncoherentEXT", AccessFlagBits2::eColorAttachmentReadNoncoherentEXT },
|
|
{ "DescriptorBufferReadEXT", AccessFlagBits2::eDescriptorBufferReadEXT },
|
|
{ "InvocationMaskReadHUAWEI", AccessFlagBits2::eInvocationMaskReadHUAWEI },
|
|
{ "ShaderBindingTableReadKHR", AccessFlagBits2::eShaderBindingTableReadKHR },
|
|
{ "MicromapReadEXT", AccessFlagBits2::eMicromapReadEXT },
|
|
{ "MicromapWriteEXT", AccessFlagBits2::eMicromapWriteEXT },
|
|
{ "OpticalFlowReadNV", AccessFlagBits2::eOpticalFlowReadNV },
|
|
{ "OpticalFlowWriteNV", AccessFlagBits2::eOpticalFlowWriteNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SubmitFlagBits> SubmitFlagBitsEntries = {
|
|
{ "Protected", SubmitFlagBits::eProtected },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, RenderingFlagBits> RenderingFlagBitsEntries = {
|
|
{ "ContentsSecondaryCommandBuffers", RenderingFlagBits::eContentsSecondaryCommandBuffers },
|
|
{ "Suspending", RenderingFlagBits::eSuspending },
|
|
{ "Resuming", RenderingFlagBits::eResuming },
|
|
{ "ContentsInlineEXT", RenderingFlagBits::eContentsInlineEXT },
|
|
{ "EnableLegacyDitheringEXT", RenderingFlagBits::eEnableLegacyDitheringEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FormatFeatureFlagBits2> FormatFeatureFlagBits2Entries = {
|
|
{ "SampledImage", FormatFeatureFlagBits2::eSampledImage },
|
|
{ "StorageImage", FormatFeatureFlagBits2::eStorageImage },
|
|
{ "StorageImageAtomic", FormatFeatureFlagBits2::eStorageImageAtomic },
|
|
{ "UniformTexelBuffer", FormatFeatureFlagBits2::eUniformTexelBuffer },
|
|
{ "StorageTexelBuffer", FormatFeatureFlagBits2::eStorageTexelBuffer },
|
|
{ "StorageTexelBufferAtomic", FormatFeatureFlagBits2::eStorageTexelBufferAtomic },
|
|
{ "VertexBuffer", FormatFeatureFlagBits2::eVertexBuffer },
|
|
{ "ColorAttachment", FormatFeatureFlagBits2::eColorAttachment },
|
|
{ "ColorAttachmentBlend", FormatFeatureFlagBits2::eColorAttachmentBlend },
|
|
{ "DepthStencilAttachment", FormatFeatureFlagBits2::eDepthStencilAttachment },
|
|
{ "BlitSrc", FormatFeatureFlagBits2::eBlitSrc },
|
|
{ "BlitDst", FormatFeatureFlagBits2::eBlitDst },
|
|
{ "SampledImageFilterLinear", FormatFeatureFlagBits2::eSampledImageFilterLinear },
|
|
{ "SampledImageFilterCubic", FormatFeatureFlagBits2::eSampledImageFilterCubic },
|
|
{ "TransferSrc", FormatFeatureFlagBits2::eTransferSrc },
|
|
{ "TransferDst", FormatFeatureFlagBits2::eTransferDst },
|
|
{ "SampledImageFilterMinmax", FormatFeatureFlagBits2::eSampledImageFilterMinmax },
|
|
{ "MidpointChromaSamples", FormatFeatureFlagBits2::eMidpointChromaSamples },
|
|
{ "SampledImageYcbcrConversionLinearFilter", FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter },
|
|
{ "SampledImageYcbcrConversionSeparateReconstructionFilter", FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter },
|
|
{ "SampledImageYcbcrConversionChromaReconstructionExplicit", FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit },
|
|
{ "SampledImageYcbcrConversionChromaReconstructionExplicitForceable",
|
|
FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable },
|
|
{ "Disjoint", FormatFeatureFlagBits2::eDisjoint },
|
|
{ "CositedChromaSamples", FormatFeatureFlagBits2::eCositedChromaSamples },
|
|
{ "StorageReadWithoutFormat", FormatFeatureFlagBits2::eStorageReadWithoutFormat },
|
|
{ "StorageWriteWithoutFormat", FormatFeatureFlagBits2::eStorageWriteWithoutFormat },
|
|
{ "SampledImageDepthComparison", FormatFeatureFlagBits2::eSampledImageDepthComparison },
|
|
{ "VideoDecodeOutputKHR", FormatFeatureFlagBits2::eVideoDecodeOutputKHR },
|
|
{ "VideoDecodeDpbKHR", FormatFeatureFlagBits2::eVideoDecodeDpbKHR },
|
|
{ "AccelerationStructureVertexBufferKHR", FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR },
|
|
{ "FragmentDensityMapEXT", FormatFeatureFlagBits2::eFragmentDensityMapEXT },
|
|
{ "FragmentShadingRateAttachmentKHR", FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR },
|
|
{ "HostImageTransferEXT", FormatFeatureFlagBits2::eHostImageTransferEXT },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeInputKHR", FormatFeatureFlagBits2::eVideoEncodeInputKHR },
|
|
{ "VideoEncodeDpbKHR", FormatFeatureFlagBits2::eVideoEncodeDpbKHR },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "LinearColorAttachmentNV", FormatFeatureFlagBits2::eLinearColorAttachmentNV },
|
|
{ "WeightImageQCOM", FormatFeatureFlagBits2::eWeightImageQCOM },
|
|
{ "WeightSampledImageQCOM", FormatFeatureFlagBits2::eWeightSampledImageQCOM },
|
|
{ "BlockMatchingQCOM", FormatFeatureFlagBits2::eBlockMatchingQCOM },
|
|
{ "BoxFilterSampledQCOM", FormatFeatureFlagBits2::eBoxFilterSampledQCOM },
|
|
{ "OpticalFlowImageNV", FormatFeatureFlagBits2::eOpticalFlowImageNV },
|
|
{ "OpticalFlowVectorNV", FormatFeatureFlagBits2::eOpticalFlowVectorNV },
|
|
{ "OpticalFlowCostNV", FormatFeatureFlagBits2::eOpticalFlowCostNV },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_surface ===
|
|
|
|
std::unordered_map<std::string, SurfaceTransformFlagBitsKHR> SurfaceTransformFlagBitsKHREntries = {
|
|
{ "Identity", SurfaceTransformFlagBitsKHR::eIdentity },
|
|
{ "Rotate90", SurfaceTransformFlagBitsKHR::eRotate90 },
|
|
{ "Rotate180", SurfaceTransformFlagBitsKHR::eRotate180 },
|
|
{ "Rotate270", SurfaceTransformFlagBitsKHR::eRotate270 },
|
|
{ "HorizontalMirror", SurfaceTransformFlagBitsKHR::eHorizontalMirror },
|
|
{ "HorizontalMirrorRotate90", SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 },
|
|
{ "HorizontalMirrorRotate180", SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 },
|
|
{ "HorizontalMirrorRotate270", SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 },
|
|
{ "Inherit", SurfaceTransformFlagBitsKHR::eInherit },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PresentModeKHR> PresentModeKHREntries = {
|
|
{ "Immediate", PresentModeKHR::eImmediate },
|
|
{ "Mailbox", PresentModeKHR::eMailbox },
|
|
{ "Fifo", PresentModeKHR::eFifo },
|
|
{ "FifoRelaxed", PresentModeKHR::eFifoRelaxed },
|
|
{ "SharedDemandRefresh", PresentModeKHR::eSharedDemandRefresh },
|
|
{ "SharedContinuousRefresh", PresentModeKHR::eSharedContinuousRefresh },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ColorSpaceKHR> ColorSpaceKHREntries = {
|
|
{ "SrgbNonlinear", ColorSpaceKHR::eSrgbNonlinear },
|
|
{ "DisplayP3NonlinearEXT", ColorSpaceKHR::eDisplayP3NonlinearEXT },
|
|
{ "ExtendedSrgbLinearEXT", ColorSpaceKHR::eExtendedSrgbLinearEXT },
|
|
{ "DisplayP3LinearEXT", ColorSpaceKHR::eDisplayP3LinearEXT },
|
|
{ "DciP3NonlinearEXT", ColorSpaceKHR::eDciP3NonlinearEXT },
|
|
{ "Bt709LinearEXT", ColorSpaceKHR::eBt709LinearEXT },
|
|
{ "Bt709NonlinearEXT", ColorSpaceKHR::eBt709NonlinearEXT },
|
|
{ "Bt2020LinearEXT", ColorSpaceKHR::eBt2020LinearEXT },
|
|
{ "Hdr10St2084EXT", ColorSpaceKHR::eHdr10St2084EXT },
|
|
{ "DolbyvisionEXT", ColorSpaceKHR::eDolbyvisionEXT },
|
|
{ "Hdr10HlgEXT", ColorSpaceKHR::eHdr10HlgEXT },
|
|
{ "AdobergbLinearEXT", ColorSpaceKHR::eAdobergbLinearEXT },
|
|
{ "AdobergbNonlinearEXT", ColorSpaceKHR::eAdobergbNonlinearEXT },
|
|
{ "PassThroughEXT", ColorSpaceKHR::ePassThroughEXT },
|
|
{ "ExtendedSrgbNonlinearEXT", ColorSpaceKHR::eExtendedSrgbNonlinearEXT },
|
|
{ "DisplayNativeAMD", ColorSpaceKHR::eDisplayNativeAMD },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CompositeAlphaFlagBitsKHR> CompositeAlphaFlagBitsKHREntries = {
|
|
{ "Opaque", CompositeAlphaFlagBitsKHR::eOpaque },
|
|
{ "PreMultiplied", CompositeAlphaFlagBitsKHR::ePreMultiplied },
|
|
{ "PostMultiplied", CompositeAlphaFlagBitsKHR::ePostMultiplied },
|
|
{ "Inherit", CompositeAlphaFlagBitsKHR::eInherit },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_swapchain ===
|
|
|
|
std::unordered_map<std::string, SwapchainCreateFlagBitsKHR> SwapchainCreateFlagBitsKHREntries = {
|
|
{ "SplitInstanceBindRegions", SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions },
|
|
{ "Protected", SwapchainCreateFlagBitsKHR::eProtected },
|
|
{ "MutableFormat", SwapchainCreateFlagBitsKHR::eMutableFormat },
|
|
{ "DeferredMemoryAllocationEXT", SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocationEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceGroupPresentModeFlagBitsKHR> DeviceGroupPresentModeFlagBitsKHREntries = {
|
|
{ "Local", DeviceGroupPresentModeFlagBitsKHR::eLocal },
|
|
{ "Remote", DeviceGroupPresentModeFlagBitsKHR::eRemote },
|
|
{ "Sum", DeviceGroupPresentModeFlagBitsKHR::eSum },
|
|
{ "LocalMultiDevice", DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_display ===
|
|
|
|
std::unordered_map<std::string, DisplayPlaneAlphaFlagBitsKHR> DisplayPlaneAlphaFlagBitsKHREntries = {
|
|
{ "Opaque", DisplayPlaneAlphaFlagBitsKHR::eOpaque },
|
|
{ "Global", DisplayPlaneAlphaFlagBitsKHR::eGlobal },
|
|
{ "PerPixel", DisplayPlaneAlphaFlagBitsKHR::ePerPixel },
|
|
{ "PerPixelPremultiplied", DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DisplayModeCreateFlagBitsKHR> DisplayModeCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DisplaySurfaceCreateFlagBitsKHR> DisplaySurfaceCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
//=== VK_KHR_xlib_surface ===
|
|
|
|
std::unordered_map<std::string, XlibSurfaceCreateFlagBitsKHR> XlibSurfaceCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
//=== VK_KHR_xcb_surface ===
|
|
|
|
std::unordered_map<std::string, XcbSurfaceCreateFlagBitsKHR> XcbSurfaceCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
//=== VK_KHR_wayland_surface ===
|
|
|
|
std::unordered_map<std::string, WaylandSurfaceCreateFlagBitsKHR> WaylandSurfaceCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
//=== VK_KHR_android_surface ===
|
|
|
|
std::unordered_map<std::string, AndroidSurfaceCreateFlagBitsKHR> AndroidSurfaceCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_KHR_win32_surface ===
|
|
|
|
std::unordered_map<std::string, Win32SurfaceCreateFlagBitsKHR> Win32SurfaceCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
//=== VK_EXT_debug_report ===
|
|
|
|
std::unordered_map<std::string, DebugReportFlagBitsEXT> DebugReportFlagBitsEXTEntries = {
|
|
{ "Information", DebugReportFlagBitsEXT::eInformation },
|
|
{ "Warning", DebugReportFlagBitsEXT::eWarning },
|
|
{ "PerformanceWarning", DebugReportFlagBitsEXT::ePerformanceWarning },
|
|
{ "Error", DebugReportFlagBitsEXT::eError },
|
|
{ "Debug", DebugReportFlagBitsEXT::eDebug },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugReportObjectTypeEXT> DebugReportObjectTypeEXTEntries = {
|
|
{ "Unknown", DebugReportObjectTypeEXT::eUnknown },
|
|
{ "Instance", DebugReportObjectTypeEXT::eInstance },
|
|
{ "PhysicalDevice", DebugReportObjectTypeEXT::ePhysicalDevice },
|
|
{ "Device", DebugReportObjectTypeEXT::eDevice },
|
|
{ "Queue", DebugReportObjectTypeEXT::eQueue },
|
|
{ "Semaphore", DebugReportObjectTypeEXT::eSemaphore },
|
|
{ "CommandBuffer", DebugReportObjectTypeEXT::eCommandBuffer },
|
|
{ "Fence", DebugReportObjectTypeEXT::eFence },
|
|
{ "DeviceMemory", DebugReportObjectTypeEXT::eDeviceMemory },
|
|
{ "Buffer", DebugReportObjectTypeEXT::eBuffer },
|
|
{ "Image", DebugReportObjectTypeEXT::eImage },
|
|
{ "Event", DebugReportObjectTypeEXT::eEvent },
|
|
{ "QueryPool", DebugReportObjectTypeEXT::eQueryPool },
|
|
{ "BufferView", DebugReportObjectTypeEXT::eBufferView },
|
|
{ "ImageView", DebugReportObjectTypeEXT::eImageView },
|
|
{ "ShaderModule", DebugReportObjectTypeEXT::eShaderModule },
|
|
{ "PipelineCache", DebugReportObjectTypeEXT::ePipelineCache },
|
|
{ "PipelineLayout", DebugReportObjectTypeEXT::ePipelineLayout },
|
|
{ "RenderPass", DebugReportObjectTypeEXT::eRenderPass },
|
|
{ "Pipeline", DebugReportObjectTypeEXT::ePipeline },
|
|
{ "DescriptorSetLayout", DebugReportObjectTypeEXT::eDescriptorSetLayout },
|
|
{ "Sampler", DebugReportObjectTypeEXT::eSampler },
|
|
{ "DescriptorPool", DebugReportObjectTypeEXT::eDescriptorPool },
|
|
{ "DescriptorSet", DebugReportObjectTypeEXT::eDescriptorSet },
|
|
{ "Framebuffer", DebugReportObjectTypeEXT::eFramebuffer },
|
|
{ "CommandPool", DebugReportObjectTypeEXT::eCommandPool },
|
|
{ "SurfaceKHR", DebugReportObjectTypeEXT::eSurfaceKHR },
|
|
{ "SwapchainKHR", DebugReportObjectTypeEXT::eSwapchainKHR },
|
|
{ "DebugReportCallbackEXT", DebugReportObjectTypeEXT::eDebugReportCallbackEXT },
|
|
{ "DisplayKHR", DebugReportObjectTypeEXT::eDisplayKHR },
|
|
{ "DisplayModeKHR", DebugReportObjectTypeEXT::eDisplayModeKHR },
|
|
{ "ValidationCacheEXT", DebugReportObjectTypeEXT::eValidationCacheEXT },
|
|
{ "SamplerYcbcrConversion", DebugReportObjectTypeEXT::eSamplerYcbcrConversion },
|
|
{ "DescriptorUpdateTemplate", DebugReportObjectTypeEXT::eDescriptorUpdateTemplate },
|
|
{ "CuModuleNVX", DebugReportObjectTypeEXT::eCuModuleNVX },
|
|
{ "CuFunctionNVX", DebugReportObjectTypeEXT::eCuFunctionNVX },
|
|
{ "AccelerationStructureKHR", DebugReportObjectTypeEXT::eAccelerationStructureKHR },
|
|
{ "AccelerationStructureNV", DebugReportObjectTypeEXT::eAccelerationStructureNV },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "CudaModuleNV", DebugReportObjectTypeEXT::eCudaModuleNV },
|
|
{ "CudaFunctionNV", DebugReportObjectTypeEXT::eCudaFunctionNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
{ "BufferCollectionFUCHSIA", DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA },
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
};
|
|
|
|
//=== VK_AMD_rasterization_order ===
|
|
|
|
std::unordered_map<std::string, RasterizationOrderAMD> RasterizationOrderAMDEntries = {
|
|
{ "Strict", RasterizationOrderAMD::eStrict },
|
|
{ "Relaxed", RasterizationOrderAMD::eRelaxed },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_video_queue ===
|
|
|
|
std::unordered_map<std::string, VideoCodecOperationFlagBitsKHR> VideoCodecOperationFlagBitsKHREntries = {
|
|
{ "None", VideoCodecOperationFlagBitsKHR::eNone },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "EncodeH264EXT", VideoCodecOperationFlagBitsKHR::eEncodeH264EXT },
|
|
{ "EncodeH265EXT", VideoCodecOperationFlagBitsKHR::eEncodeH265EXT },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "DecodeH264", VideoCodecOperationFlagBitsKHR::eDecodeH264 },
|
|
{ "DecodeH265", VideoCodecOperationFlagBitsKHR::eDecodeH265 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoChromaSubsamplingFlagBitsKHR> VideoChromaSubsamplingFlagBitsKHREntries = {
|
|
{ "Invalid", VideoChromaSubsamplingFlagBitsKHR::eInvalid }, { "Monochrome", VideoChromaSubsamplingFlagBitsKHR::eMonochrome },
|
|
{ "420", VideoChromaSubsamplingFlagBitsKHR::e420 }, { "422", VideoChromaSubsamplingFlagBitsKHR::e422 },
|
|
{ "444", VideoChromaSubsamplingFlagBitsKHR::e444 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoComponentBitDepthFlagBitsKHR> VideoComponentBitDepthFlagBitsKHREntries = {
|
|
{ "Invalid", VideoComponentBitDepthFlagBitsKHR::eInvalid },
|
|
{ "8", VideoComponentBitDepthFlagBitsKHR::e8 },
|
|
{ "10", VideoComponentBitDepthFlagBitsKHR::e10 },
|
|
{ "12", VideoComponentBitDepthFlagBitsKHR::e12 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoCapabilityFlagBitsKHR> VideoCapabilityFlagBitsKHREntries = {
|
|
{ "ProtectedContent", VideoCapabilityFlagBitsKHR::eProtectedContent },
|
|
{ "SeparateReferenceImages", VideoCapabilityFlagBitsKHR::eSeparateReferenceImages },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoSessionCreateFlagBitsKHR> VideoSessionCreateFlagBitsKHREntries = {
|
|
{ "ProtectedContent", VideoSessionCreateFlagBitsKHR::eProtectedContent },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "AllowEncodeParameterOptimizations", VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoCodingControlFlagBitsKHR> VideoCodingControlFlagBitsKHREntries = {
|
|
{ "Reset", VideoCodingControlFlagBitsKHR::eReset },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "EncodeRateControl", VideoCodingControlFlagBitsKHR::eEncodeRateControl },
|
|
{ "EncodeQualityLevel", VideoCodingControlFlagBitsKHR::eEncodeQualityLevel },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryResultStatusKHR> QueryResultStatusKHREntries = {
|
|
{ "Error", QueryResultStatusKHR::eError },
|
|
{ "NotReady", QueryResultStatusKHR::eNotReady },
|
|
{ "Complete", QueryResultStatusKHR::eComplete },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "InsufficientBitstreamBufferRange", QueryResultStatusKHR::eInsufficientBitstreamBufferRange },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoSessionParametersCreateFlagBitsKHR> VideoSessionParametersCreateFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoBeginCodingFlagBitsKHR> VideoBeginCodingFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEndCodingFlagBitsKHR> VideoEndCodingFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
//=== VK_KHR_video_decode_queue ===
|
|
|
|
std::unordered_map<std::string, VideoDecodeCapabilityFlagBitsKHR> VideoDecodeCapabilityFlagBitsKHREntries = {
|
|
{ "DpbAndOutputCoincide", VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide },
|
|
{ "DpbAndOutputDistinct", VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoDecodeUsageFlagBitsKHR> VideoDecodeUsageFlagBitsKHREntries = {
|
|
{ "Default", VideoDecodeUsageFlagBitsKHR::eDefault },
|
|
{ "Transcoding", VideoDecodeUsageFlagBitsKHR::eTranscoding },
|
|
{ "Offline", VideoDecodeUsageFlagBitsKHR::eOffline },
|
|
{ "Streaming", VideoDecodeUsageFlagBitsKHR::eStreaming },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoDecodeFlagBitsKHR> VideoDecodeFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_transform_feedback ===
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationStateStreamCreateFlagBitsEXT> PipelineRasterizationStateStreamCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_EXT_video_encode_h264 ===
|
|
|
|
std::unordered_map<std::string, VideoEncodeH264CapabilityFlagBitsEXT> VideoEncodeH264CapabilityFlagBitsEXTEntries = {
|
|
{ "HrdCompliance", VideoEncodeH264CapabilityFlagBitsEXT::eHrdCompliance },
|
|
{ "PredictionWeightTableGenerated", VideoEncodeH264CapabilityFlagBitsEXT::ePredictionWeightTableGenerated },
|
|
{ "RowUnalignedSlice", VideoEncodeH264CapabilityFlagBitsEXT::eRowUnalignedSlice },
|
|
{ "DifferentSliceType", VideoEncodeH264CapabilityFlagBitsEXT::eDifferentSliceType },
|
|
{ "BFrameInL0List", VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL0List },
|
|
{ "BFrameInL1List", VideoEncodeH264CapabilityFlagBitsEXT::eBFrameInL1List },
|
|
{ "PerPictureTypeMinMaxQp", VideoEncodeH264CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp },
|
|
{ "PerSliceConstantQp", VideoEncodeH264CapabilityFlagBitsEXT::ePerSliceConstantQp },
|
|
{ "GeneratePrefixNalu", VideoEncodeH264CapabilityFlagBitsEXT::eGeneratePrefixNalu },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH264StdFlagBitsEXT> VideoEncodeH264StdFlagBitsEXTEntries = {
|
|
{ "SeparateColorPlaneFlagSet", VideoEncodeH264StdFlagBitsEXT::eSeparateColorPlaneFlagSet },
|
|
{ "QpprimeYZeroTransformBypassFlagSet", VideoEncodeH264StdFlagBitsEXT::eQpprimeYZeroTransformBypassFlagSet },
|
|
{ "ScalingMatrixPresentFlagSet", VideoEncodeH264StdFlagBitsEXT::eScalingMatrixPresentFlagSet },
|
|
{ "ChromaQpIndexOffset", VideoEncodeH264StdFlagBitsEXT::eChromaQpIndexOffset },
|
|
{ "SecondChromaQpIndexOffset", VideoEncodeH264StdFlagBitsEXT::eSecondChromaQpIndexOffset },
|
|
{ "PicInitQpMinus26", VideoEncodeH264StdFlagBitsEXT::ePicInitQpMinus26 },
|
|
{ "WeightedPredFlagSet", VideoEncodeH264StdFlagBitsEXT::eWeightedPredFlagSet },
|
|
{ "WeightedBipredIdcExplicit", VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcExplicit },
|
|
{ "WeightedBipredIdcImplicit", VideoEncodeH264StdFlagBitsEXT::eWeightedBipredIdcImplicit },
|
|
{ "Transform8X8ModeFlagSet", VideoEncodeH264StdFlagBitsEXT::eTransform8X8ModeFlagSet },
|
|
{ "DirectSpatialMvPredFlagUnset", VideoEncodeH264StdFlagBitsEXT::eDirectSpatialMvPredFlagUnset },
|
|
{ "EntropyCodingModeFlagUnset", VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagUnset },
|
|
{ "EntropyCodingModeFlagSet", VideoEncodeH264StdFlagBitsEXT::eEntropyCodingModeFlagSet },
|
|
{ "Direct8X8InferenceFlagUnset", VideoEncodeH264StdFlagBitsEXT::eDirect8X8InferenceFlagUnset },
|
|
{ "ConstrainedIntraPredFlagSet", VideoEncodeH264StdFlagBitsEXT::eConstrainedIntraPredFlagSet },
|
|
{ "DeblockingFilterDisabled", VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterDisabled },
|
|
{ "DeblockingFilterEnabled", VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterEnabled },
|
|
{ "DeblockingFilterPartial", VideoEncodeH264StdFlagBitsEXT::eDeblockingFilterPartial },
|
|
{ "SliceQpDelta", VideoEncodeH264StdFlagBitsEXT::eSliceQpDelta },
|
|
{ "DifferentSliceQpDelta", VideoEncodeH264StdFlagBitsEXT::eDifferentSliceQpDelta },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH264RateControlFlagBitsEXT> VideoEncodeH264RateControlFlagBitsEXTEntries = {
|
|
{ "AttemptHrdCompliance", VideoEncodeH264RateControlFlagBitsEXT::eAttemptHrdCompliance },
|
|
{ "RegularGop", VideoEncodeH264RateControlFlagBitsEXT::eRegularGop },
|
|
{ "ReferencePatternFlat", VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternFlat },
|
|
{ "ReferencePatternDyadic", VideoEncodeH264RateControlFlagBitsEXT::eReferencePatternDyadic },
|
|
{ "TemporalLayerPatternDyadic", VideoEncodeH264RateControlFlagBitsEXT::eTemporalLayerPatternDyadic },
|
|
|
|
};
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_EXT_video_encode_h265 ===
|
|
|
|
std::unordered_map<std::string, VideoEncodeH265CapabilityFlagBitsEXT> VideoEncodeH265CapabilityFlagBitsEXTEntries = {
|
|
{ "HrdCompliance", VideoEncodeH265CapabilityFlagBitsEXT::eHrdCompliance },
|
|
{ "PredictionWeightTableGenerated", VideoEncodeH265CapabilityFlagBitsEXT::ePredictionWeightTableGenerated },
|
|
{ "RowUnalignedSliceSegment", VideoEncodeH265CapabilityFlagBitsEXT::eRowUnalignedSliceSegment },
|
|
{ "DifferentSliceSegmentType", VideoEncodeH265CapabilityFlagBitsEXT::eDifferentSliceSegmentType },
|
|
{ "BFrameInL0List", VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL0List },
|
|
{ "BFrameInL1List", VideoEncodeH265CapabilityFlagBitsEXT::eBFrameInL1List },
|
|
{ "PerPictureTypeMinMaxQp", VideoEncodeH265CapabilityFlagBitsEXT::ePerPictureTypeMinMaxQp },
|
|
{ "PerSliceSegmentConstantQp", VideoEncodeH265CapabilityFlagBitsEXT::ePerSliceSegmentConstantQp },
|
|
{ "MultipleTilesPerSliceSegment", VideoEncodeH265CapabilityFlagBitsEXT::eMultipleTilesPerSliceSegment },
|
|
{ "MultipleSliceSegmentsPerTile", VideoEncodeH265CapabilityFlagBitsEXT::eMultipleSliceSegmentsPerTile },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH265StdFlagBitsEXT> VideoEncodeH265StdFlagBitsEXTEntries = {
|
|
{ "SeparateColorPlaneFlagSet", VideoEncodeH265StdFlagBitsEXT::eSeparateColorPlaneFlagSet },
|
|
{ "SampleAdaptiveOffsetEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eSampleAdaptiveOffsetEnabledFlagSet },
|
|
{ "ScalingListDataPresentFlagSet", VideoEncodeH265StdFlagBitsEXT::eScalingListDataPresentFlagSet },
|
|
{ "PcmEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::ePcmEnabledFlagSet },
|
|
{ "SpsTemporalMvpEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eSpsTemporalMvpEnabledFlagSet },
|
|
{ "InitQpMinus26", VideoEncodeH265StdFlagBitsEXT::eInitQpMinus26 },
|
|
{ "WeightedPredFlagSet", VideoEncodeH265StdFlagBitsEXT::eWeightedPredFlagSet },
|
|
{ "WeightedBipredFlagSet", VideoEncodeH265StdFlagBitsEXT::eWeightedBipredFlagSet },
|
|
{ "Log2ParallelMergeLevelMinus2", VideoEncodeH265StdFlagBitsEXT::eLog2ParallelMergeLevelMinus2 },
|
|
{ "SignDataHidingEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eSignDataHidingEnabledFlagSet },
|
|
{ "TransformSkipEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagSet },
|
|
{ "TransformSkipEnabledFlagUnset", VideoEncodeH265StdFlagBitsEXT::eTransformSkipEnabledFlagUnset },
|
|
{ "PpsSliceChromaQpOffsetsPresentFlagSet", VideoEncodeH265StdFlagBitsEXT::ePpsSliceChromaQpOffsetsPresentFlagSet },
|
|
{ "TransquantBypassEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eTransquantBypassEnabledFlagSet },
|
|
{ "ConstrainedIntraPredFlagSet", VideoEncodeH265StdFlagBitsEXT::eConstrainedIntraPredFlagSet },
|
|
{ "EntropyCodingSyncEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eEntropyCodingSyncEnabledFlagSet },
|
|
{ "DeblockingFilterOverrideEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eDeblockingFilterOverrideEnabledFlagSet },
|
|
{ "DependentSliceSegmentsEnabledFlagSet", VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentsEnabledFlagSet },
|
|
{ "DependentSliceSegmentFlagSet", VideoEncodeH265StdFlagBitsEXT::eDependentSliceSegmentFlagSet },
|
|
{ "SliceQpDelta", VideoEncodeH265StdFlagBitsEXT::eSliceQpDelta },
|
|
{ "DifferentSliceQpDelta", VideoEncodeH265StdFlagBitsEXT::eDifferentSliceQpDelta },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH265CtbSizeFlagBitsEXT> VideoEncodeH265CtbSizeFlagBitsEXTEntries = {
|
|
{ "16", VideoEncodeH265CtbSizeFlagBitsEXT::e16 },
|
|
{ "32", VideoEncodeH265CtbSizeFlagBitsEXT::e32 },
|
|
{ "64", VideoEncodeH265CtbSizeFlagBitsEXT::e64 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH265TransformBlockSizeFlagBitsEXT> VideoEncodeH265TransformBlockSizeFlagBitsEXTEntries = {
|
|
{ "4", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 },
|
|
{ "8", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 },
|
|
{ "16", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 },
|
|
{ "32", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH265RateControlFlagBitsEXT> VideoEncodeH265RateControlFlagBitsEXTEntries = {
|
|
{ "AttemptHrdCompliance", VideoEncodeH265RateControlFlagBitsEXT::eAttemptHrdCompliance },
|
|
{ "RegularGop", VideoEncodeH265RateControlFlagBitsEXT::eRegularGop },
|
|
{ "ReferencePatternFlat", VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternFlat },
|
|
{ "ReferencePatternDyadic", VideoEncodeH265RateControlFlagBitsEXT::eReferencePatternDyadic },
|
|
{ "TemporalSubLayerPatternDyadic", VideoEncodeH265RateControlFlagBitsEXT::eTemporalSubLayerPatternDyadic },
|
|
|
|
};
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_KHR_video_decode_h264 ===
|
|
|
|
std::unordered_map<std::string, VideoDecodeH264PictureLayoutFlagBitsKHR> VideoDecodeH264PictureLayoutFlagBitsKHREntries = {
|
|
{ "Progressive", VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive },
|
|
{ "InterlacedInterleavedLines", VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines },
|
|
{ "InterlacedSeparatePlanes", VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes },
|
|
|
|
};
|
|
|
|
//=== VK_AMD_shader_info ===
|
|
|
|
std::unordered_map<std::string, ShaderInfoTypeAMD> ShaderInfoTypeAMDEntries = {
|
|
{ "Statistics", ShaderInfoTypeAMD::eStatistics },
|
|
{ "Binary", ShaderInfoTypeAMD::eBinary },
|
|
{ "Disassembly", ShaderInfoTypeAMD::eDisassembly },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_GGP )
|
|
//=== VK_GGP_stream_descriptor_surface ===
|
|
|
|
std::unordered_map<std::string, StreamDescriptorSurfaceCreateFlagBitsGGP> StreamDescriptorSurfaceCreateFlagBitsGGPEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_GGP*/
|
|
|
|
//=== VK_NV_external_memory_capabilities ===
|
|
|
|
std::unordered_map<std::string, ExternalMemoryHandleTypeFlagBitsNV> ExternalMemoryHandleTypeFlagBitsNVEntries = {
|
|
{ "OpaqueWin32", ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 },
|
|
{ "OpaqueWin32Kmt", ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt },
|
|
{ "D3D11Image", ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image },
|
|
{ "D3D11ImageKmt", ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalMemoryFeatureFlagBitsNV> ExternalMemoryFeatureFlagBitsNVEntries = {
|
|
{ "DedicatedOnly", ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly },
|
|
{ "Exportable", ExternalMemoryFeatureFlagBitsNV::eExportable },
|
|
{ "Importable", ExternalMemoryFeatureFlagBitsNV::eImportable },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_validation_flags ===
|
|
|
|
std::unordered_map<std::string, ValidationCheckEXT> ValidationCheckEXTEntries = {
|
|
{ "All", ValidationCheckEXT::eAll },
|
|
{ "Shaders", ValidationCheckEXT::eShaders },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_VI_NN )
|
|
//=== VK_NN_vi_surface ===
|
|
|
|
std::unordered_map<std::string, ViSurfaceCreateFlagBitsNN> ViSurfaceCreateFlagBitsNNEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
|
//=== VK_EXT_pipeline_robustness ===
|
|
|
|
std::unordered_map<std::string, PipelineRobustnessBufferBehaviorEXT> PipelineRobustnessBufferBehaviorEXTEntries = {
|
|
{ "DeviceDefault", PipelineRobustnessBufferBehaviorEXT::eDeviceDefault },
|
|
{ "Disabled", PipelineRobustnessBufferBehaviorEXT::eDisabled },
|
|
{ "RobustBufferAccess", PipelineRobustnessBufferBehaviorEXT::eRobustBufferAccess },
|
|
{ "RobustBufferAccess2", PipelineRobustnessBufferBehaviorEXT::eRobustBufferAccess2 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineRobustnessImageBehaviorEXT> PipelineRobustnessImageBehaviorEXTEntries = {
|
|
{ "DeviceDefault", PipelineRobustnessImageBehaviorEXT::eDeviceDefault },
|
|
{ "Disabled", PipelineRobustnessImageBehaviorEXT::eDisabled },
|
|
{ "RobustImageAccess", PipelineRobustnessImageBehaviorEXT::eRobustImageAccess },
|
|
{ "RobustImageAccess2", PipelineRobustnessImageBehaviorEXT::eRobustImageAccess2 },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_conditional_rendering ===
|
|
|
|
std::unordered_map<std::string, ConditionalRenderingFlagBitsEXT> ConditionalRenderingFlagBitsEXTEntries = {
|
|
{ "Inverted", ConditionalRenderingFlagBitsEXT::eInverted },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_display_surface_counter ===
|
|
|
|
std::unordered_map<std::string, SurfaceCounterFlagBitsEXT> SurfaceCounterFlagBitsEXTEntries = {
|
|
{ "Vblank", SurfaceCounterFlagBitsEXT::eVblank },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_display_control ===
|
|
|
|
std::unordered_map<std::string, DisplayPowerStateEXT> DisplayPowerStateEXTEntries = {
|
|
{ "Off", DisplayPowerStateEXT::eOff },
|
|
{ "Suspend", DisplayPowerStateEXT::eSuspend },
|
|
{ "On", DisplayPowerStateEXT::eOn },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceEventTypeEXT> DeviceEventTypeEXTEntries = {
|
|
{ "DisplayHotplug", DeviceEventTypeEXT::eDisplayHotplug },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DisplayEventTypeEXT> DisplayEventTypeEXTEntries = {
|
|
{ "FirstPixelOut", DisplayEventTypeEXT::eFirstPixelOut },
|
|
|
|
};
|
|
|
|
//=== VK_NV_viewport_swizzle ===
|
|
|
|
std::unordered_map<std::string, ViewportCoordinateSwizzleNV> ViewportCoordinateSwizzleNVEntries = {
|
|
{ "PositiveX", ViewportCoordinateSwizzleNV::ePositiveX }, { "NegativeX", ViewportCoordinateSwizzleNV::eNegativeX },
|
|
{ "PositiveY", ViewportCoordinateSwizzleNV::ePositiveY }, { "NegativeY", ViewportCoordinateSwizzleNV::eNegativeY },
|
|
{ "PositiveZ", ViewportCoordinateSwizzleNV::ePositiveZ }, { "NegativeZ", ViewportCoordinateSwizzleNV::eNegativeZ },
|
|
{ "PositiveW", ViewportCoordinateSwizzleNV::ePositiveW }, { "NegativeW", ViewportCoordinateSwizzleNV::eNegativeW },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineViewportSwizzleStateCreateFlagBitsNV> PipelineViewportSwizzleStateCreateFlagBitsNVEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_discard_rectangles ===
|
|
|
|
std::unordered_map<std::string, DiscardRectangleModeEXT> DiscardRectangleModeEXTEntries = {
|
|
{ "Inclusive", DiscardRectangleModeEXT::eInclusive },
|
|
{ "Exclusive", DiscardRectangleModeEXT::eExclusive },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineDiscardRectangleStateCreateFlagBitsEXT> PipelineDiscardRectangleStateCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_conservative_rasterization ===
|
|
|
|
std::unordered_map<std::string, ConservativeRasterizationModeEXT> ConservativeRasterizationModeEXTEntries = {
|
|
{ "Disabled", ConservativeRasterizationModeEXT::eDisabled },
|
|
{ "Overestimate", ConservativeRasterizationModeEXT::eOverestimate },
|
|
{ "Underestimate", ConservativeRasterizationModeEXT::eUnderestimate },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationConservativeStateCreateFlagBitsEXT> PipelineRasterizationConservativeStateCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_depth_clip_enable ===
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationDepthClipStateCreateFlagBitsEXT> PipelineRasterizationDepthClipStateCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_KHR_performance_query ===
|
|
|
|
std::unordered_map<std::string, PerformanceCounterDescriptionFlagBitsKHR> PerformanceCounterDescriptionFlagBitsKHREntries = {
|
|
{ "PerformanceImpacting", PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting },
|
|
{ "ConcurrentlyImpacted", PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceCounterScopeKHR> PerformanceCounterScopeKHREntries = {
|
|
{ "CommandBuffer", PerformanceCounterScopeKHR::eCommandBuffer },
|
|
{ "RenderPass", PerformanceCounterScopeKHR::eRenderPass },
|
|
{ "Command", PerformanceCounterScopeKHR::eCommand },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceCounterStorageKHR> PerformanceCounterStorageKHREntries = {
|
|
{ "Int32", PerformanceCounterStorageKHR::eInt32 }, { "Int64", PerformanceCounterStorageKHR::eInt64 },
|
|
{ "Uint32", PerformanceCounterStorageKHR::eUint32 }, { "Uint64", PerformanceCounterStorageKHR::eUint64 },
|
|
{ "Float32", PerformanceCounterStorageKHR::eFloat32 }, { "Float64", PerformanceCounterStorageKHR::eFloat64 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceCounterUnitKHR> PerformanceCounterUnitKHREntries = {
|
|
{ "Generic", PerformanceCounterUnitKHR::eGeneric },
|
|
{ "Percentage", PerformanceCounterUnitKHR::ePercentage },
|
|
{ "Nanoseconds", PerformanceCounterUnitKHR::eNanoseconds },
|
|
{ "Bytes", PerformanceCounterUnitKHR::eBytes },
|
|
{ "BytesPerSecond", PerformanceCounterUnitKHR::eBytesPerSecond },
|
|
{ "Kelvin", PerformanceCounterUnitKHR::eKelvin },
|
|
{ "Watts", PerformanceCounterUnitKHR::eWatts },
|
|
{ "Volts", PerformanceCounterUnitKHR::eVolts },
|
|
{ "Amps", PerformanceCounterUnitKHR::eAmps },
|
|
{ "Hertz", PerformanceCounterUnitKHR::eHertz },
|
|
{ "Cycles", PerformanceCounterUnitKHR::eCycles },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AcquireProfilingLockFlagBitsKHR> AcquireProfilingLockFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
//=== VK_MVK_ios_surface ===
|
|
|
|
std::unordered_map<std::string, IOSSurfaceCreateFlagBitsMVK> IOSSurfaceCreateFlagBitsMVKEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
|
#if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
//=== VK_MVK_macos_surface ===
|
|
|
|
std::unordered_map<std::string, MacOSSurfaceCreateFlagBitsMVK> MacOSSurfaceCreateFlagBitsMVKEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
|
//=== VK_EXT_debug_utils ===
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessageSeverityFlagBitsEXT> DebugUtilsMessageSeverityFlagBitsEXTEntries = {
|
|
{ "Verbose", DebugUtilsMessageSeverityFlagBitsEXT::eVerbose },
|
|
{ "Info", DebugUtilsMessageSeverityFlagBitsEXT::eInfo },
|
|
{ "Warning", DebugUtilsMessageSeverityFlagBitsEXT::eWarning },
|
|
{ "Error", DebugUtilsMessageSeverityFlagBitsEXT::eError },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessageTypeFlagBitsEXT> DebugUtilsMessageTypeFlagBitsEXTEntries = {
|
|
{ "General", DebugUtilsMessageTypeFlagBitsEXT::eGeneral },
|
|
{ "Validation", DebugUtilsMessageTypeFlagBitsEXT::eValidation },
|
|
{ "Performance", DebugUtilsMessageTypeFlagBitsEXT::ePerformance },
|
|
{ "DeviceAddressBinding", DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessengerCallbackDataFlagBitsEXT> DebugUtilsMessengerCallbackDataFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessengerCreateFlagBitsEXT> DebugUtilsMessengerCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_blend_operation_advanced ===
|
|
|
|
std::unordered_map<std::string, BlendOverlapEXT> BlendOverlapEXTEntries = {
|
|
{ "Uncorrelated", BlendOverlapEXT::eUncorrelated },
|
|
{ "Disjoint", BlendOverlapEXT::eDisjoint },
|
|
{ "Conjoint", BlendOverlapEXT::eConjoint },
|
|
|
|
};
|
|
|
|
//=== VK_NV_fragment_coverage_to_color ===
|
|
|
|
std::unordered_map<std::string, PipelineCoverageToColorStateCreateFlagBitsNV> PipelineCoverageToColorStateCreateFlagBitsNVEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_KHR_acceleration_structure ===
|
|
|
|
std::unordered_map<std::string, AccelerationStructureTypeKHR> AccelerationStructureTypeKHREntries = {
|
|
{ "TopLevel", AccelerationStructureTypeKHR::eTopLevel },
|
|
{ "BottomLevel", AccelerationStructureTypeKHR::eBottomLevel },
|
|
{ "Generic", AccelerationStructureTypeKHR::eGeneric },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureBuildTypeKHR> AccelerationStructureBuildTypeKHREntries = {
|
|
{ "Host", AccelerationStructureBuildTypeKHR::eHost },
|
|
{ "Device", AccelerationStructureBuildTypeKHR::eDevice },
|
|
{ "HostOrDevice", AccelerationStructureBuildTypeKHR::eHostOrDevice },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, GeometryFlagBitsKHR> GeometryFlagBitsKHREntries = {
|
|
{ "Opaque", GeometryFlagBitsKHR::eOpaque },
|
|
{ "NoDuplicateAnyHitInvocation", GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, GeometryInstanceFlagBitsKHR> GeometryInstanceFlagBitsKHREntries = {
|
|
{ "TriangleFacingCullDisable", GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable },
|
|
{ "TriangleFlipFacing", GeometryInstanceFlagBitsKHR::eTriangleFlipFacing },
|
|
{ "ForceOpaque", GeometryInstanceFlagBitsKHR::eForceOpaque },
|
|
{ "ForceNoOpaque", GeometryInstanceFlagBitsKHR::eForceNoOpaque },
|
|
{ "ForceOpacityMicromap2StateEXT", GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT },
|
|
{ "DisableOpacityMicromapsEXT", GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildAccelerationStructureFlagBitsKHR> BuildAccelerationStructureFlagBitsKHREntries = {
|
|
{ "AllowUpdate", BuildAccelerationStructureFlagBitsKHR::eAllowUpdate },
|
|
{ "AllowCompaction", BuildAccelerationStructureFlagBitsKHR::eAllowCompaction },
|
|
{ "PreferFastTrace", BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace },
|
|
{ "PreferFastBuild", BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild },
|
|
{ "LowMemory", BuildAccelerationStructureFlagBitsKHR::eLowMemory },
|
|
{ "MotionNV", BuildAccelerationStructureFlagBitsKHR::eMotionNV },
|
|
{ "AllowOpacityMicromapUpdateEXT", BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT },
|
|
{ "AllowDisableOpacityMicromapsEXT", BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT },
|
|
{ "AllowOpacityMicromapDataUpdateEXT", BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "AllowDisplacementMicromapUpdateNV", BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "AllowDataAccess", BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CopyAccelerationStructureModeKHR> CopyAccelerationStructureModeKHREntries = {
|
|
{ "Clone", CopyAccelerationStructureModeKHR::eClone },
|
|
{ "Compact", CopyAccelerationStructureModeKHR::eCompact },
|
|
{ "Serialize", CopyAccelerationStructureModeKHR::eSerialize },
|
|
{ "Deserialize", CopyAccelerationStructureModeKHR::eDeserialize },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, GeometryTypeKHR> GeometryTypeKHREntries = {
|
|
{ "Triangles", GeometryTypeKHR::eTriangles },
|
|
{ "Aabbs", GeometryTypeKHR::eAabbs },
|
|
{ "Instances", GeometryTypeKHR::eInstances },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureCompatibilityKHR> AccelerationStructureCompatibilityKHREntries = {
|
|
{ "Compatible", AccelerationStructureCompatibilityKHR::eCompatible },
|
|
{ "Incompatible", AccelerationStructureCompatibilityKHR::eIncompatible },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureCreateFlagBitsKHR> AccelerationStructureCreateFlagBitsKHREntries = {
|
|
{ "DeviceAddressCaptureReplay", AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay },
|
|
{ "DescriptorBufferCaptureReplayEXT", AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT },
|
|
{ "MotionNV", AccelerationStructureCreateFlagBitsKHR::eMotionNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildAccelerationStructureModeKHR> BuildAccelerationStructureModeKHREntries = {
|
|
{ "Build", BuildAccelerationStructureModeKHR::eBuild },
|
|
{ "Update", BuildAccelerationStructureModeKHR::eUpdate },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_ray_tracing_pipeline ===
|
|
|
|
std::unordered_map<std::string, RayTracingShaderGroupTypeKHR> RayTracingShaderGroupTypeKHREntries = {
|
|
{ "General", RayTracingShaderGroupTypeKHR::eGeneral },
|
|
{ "TrianglesHitGroup", RayTracingShaderGroupTypeKHR::eTrianglesHitGroup },
|
|
{ "ProceduralHitGroup", RayTracingShaderGroupTypeKHR::eProceduralHitGroup },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ShaderGroupShaderKHR> ShaderGroupShaderKHREntries = {
|
|
{ "General", ShaderGroupShaderKHR::eGeneral },
|
|
{ "ClosestHit", ShaderGroupShaderKHR::eClosestHit },
|
|
{ "AnyHit", ShaderGroupShaderKHR::eAnyHit },
|
|
{ "Intersection", ShaderGroupShaderKHR::eIntersection },
|
|
|
|
};
|
|
|
|
//=== VK_NV_framebuffer_mixed_samples ===
|
|
|
|
std::unordered_map<std::string, CoverageModulationModeNV> CoverageModulationModeNVEntries = {
|
|
{ "None", CoverageModulationModeNV::eNone },
|
|
{ "Rgb", CoverageModulationModeNV::eRgb },
|
|
{ "Alpha", CoverageModulationModeNV::eAlpha },
|
|
{ "Rgba", CoverageModulationModeNV::eRgba },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCoverageModulationStateCreateFlagBitsNV> PipelineCoverageModulationStateCreateFlagBitsNVEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_validation_cache ===
|
|
|
|
std::unordered_map<std::string, ValidationCacheHeaderVersionEXT> ValidationCacheHeaderVersionEXTEntries = {
|
|
{ "One", ValidationCacheHeaderVersionEXT::eOne },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ValidationCacheCreateFlagBitsEXT> ValidationCacheCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_NV_shading_rate_image ===
|
|
|
|
std::unordered_map<std::string, ShadingRatePaletteEntryNV> ShadingRatePaletteEntryNVEntries = {
|
|
{ "NoInvocations", ShadingRatePaletteEntryNV::eNoInvocations },
|
|
{ "16InvocationsPerPixel", ShadingRatePaletteEntryNV::e16InvocationsPerPixel },
|
|
{ "8InvocationsPerPixel", ShadingRatePaletteEntryNV::e8InvocationsPerPixel },
|
|
{ "4InvocationsPerPixel", ShadingRatePaletteEntryNV::e4InvocationsPerPixel },
|
|
{ "2InvocationsPerPixel", ShadingRatePaletteEntryNV::e2InvocationsPerPixel },
|
|
{ "1InvocationPerPixel", ShadingRatePaletteEntryNV::e1InvocationPerPixel },
|
|
{ "1InvocationPer2X1Pixels", ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels },
|
|
{ "1InvocationPer1X2Pixels", ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels },
|
|
{ "1InvocationPer2X2Pixels", ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels },
|
|
{ "1InvocationPer4X2Pixels", ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels },
|
|
{ "1InvocationPer2X4Pixels", ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels },
|
|
{ "1InvocationPer4X4Pixels", ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CoarseSampleOrderTypeNV> CoarseSampleOrderTypeNVEntries = {
|
|
{ "Default", CoarseSampleOrderTypeNV::eDefault },
|
|
{ "Custom", CoarseSampleOrderTypeNV::eCustom },
|
|
{ "PixelMajor", CoarseSampleOrderTypeNV::ePixelMajor },
|
|
{ "SampleMajor", CoarseSampleOrderTypeNV::eSampleMajor },
|
|
|
|
};
|
|
|
|
//=== VK_NV_ray_tracing ===
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMemoryRequirementsTypeNV> AccelerationStructureMemoryRequirementsTypeNVEntries = {
|
|
{ "Object", AccelerationStructureMemoryRequirementsTypeNV::eObject },
|
|
{ "BuildScratch", AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch },
|
|
{ "UpdateScratch", AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch },
|
|
|
|
};
|
|
|
|
//=== VK_AMD_pipeline_compiler_control ===
|
|
|
|
std::unordered_map<std::string, PipelineCompilerControlFlagBitsAMD> PipelineCompilerControlFlagBitsAMDEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_calibrated_timestamps ===
|
|
|
|
std::unordered_map<std::string, TimeDomainEXT> TimeDomainEXTEntries = {
|
|
{ "Device", TimeDomainEXT::eDevice },
|
|
{ "ClockMonotonic", TimeDomainEXT::eClockMonotonic },
|
|
{ "ClockMonotonicRaw", TimeDomainEXT::eClockMonotonicRaw },
|
|
{ "QueryPerformanceCounter", TimeDomainEXT::eQueryPerformanceCounter },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_global_priority ===
|
|
|
|
std::unordered_map<std::string, QueueGlobalPriorityKHR> QueueGlobalPriorityKHREntries = {
|
|
{ "Low", QueueGlobalPriorityKHR::eLow },
|
|
{ "Medium", QueueGlobalPriorityKHR::eMedium },
|
|
{ "High", QueueGlobalPriorityKHR::eHigh },
|
|
{ "Realtime", QueueGlobalPriorityKHR::eRealtime },
|
|
|
|
};
|
|
|
|
//=== VK_AMD_memory_overallocation_behavior ===
|
|
|
|
std::unordered_map<std::string, MemoryOverallocationBehaviorAMD> MemoryOverallocationBehaviorAMDEntries = {
|
|
{ "Default", MemoryOverallocationBehaviorAMD::eDefault },
|
|
{ "Allowed", MemoryOverallocationBehaviorAMD::eAllowed },
|
|
{ "Disallowed", MemoryOverallocationBehaviorAMD::eDisallowed },
|
|
|
|
};
|
|
|
|
//=== VK_INTEL_performance_query ===
|
|
|
|
std::unordered_map<std::string, PerformanceConfigurationTypeINTEL> PerformanceConfigurationTypeINTELEntries = {
|
|
{ "CommandQueueMetricsDiscoveryActivated", PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryPoolSamplingModeINTEL> QueryPoolSamplingModeINTELEntries = {
|
|
{ "Manual", QueryPoolSamplingModeINTEL::eManual },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceOverrideTypeINTEL> PerformanceOverrideTypeINTELEntries = {
|
|
{ "NullHardware", PerformanceOverrideTypeINTEL::eNullHardware },
|
|
{ "FlushGpuCaches", PerformanceOverrideTypeINTEL::eFlushGpuCaches },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceParameterTypeINTEL> PerformanceParameterTypeINTELEntries = {
|
|
{ "HwCountersSupported", PerformanceParameterTypeINTEL::eHwCountersSupported },
|
|
{ "StreamMarkerValidBits", PerformanceParameterTypeINTEL::eStreamMarkerValidBits },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceValueTypeINTEL> PerformanceValueTypeINTELEntries = {
|
|
{ "Uint32", PerformanceValueTypeINTEL::eUint32 }, { "Uint64", PerformanceValueTypeINTEL::eUint64 }, { "Float", PerformanceValueTypeINTEL::eFloat },
|
|
{ "Bool", PerformanceValueTypeINTEL::eBool }, { "String", PerformanceValueTypeINTEL::eString },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
|
std::unordered_map<std::string, ImagePipeSurfaceCreateFlagBitsFUCHSIA> ImagePipeSurfaceCreateFlagBitsFUCHSIAEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
//=== VK_EXT_metal_surface ===
|
|
|
|
std::unordered_map<std::string, MetalSurfaceCreateFlagBitsEXT> MetalSurfaceCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
|
//=== VK_KHR_fragment_shading_rate ===
|
|
|
|
std::unordered_map<std::string, FragmentShadingRateCombinerOpKHR> FragmentShadingRateCombinerOpKHREntries = {
|
|
{ "Keep", FragmentShadingRateCombinerOpKHR::eKeep }, { "Replace", FragmentShadingRateCombinerOpKHR::eReplace },
|
|
{ "Min", FragmentShadingRateCombinerOpKHR::eMin }, { "Max", FragmentShadingRateCombinerOpKHR::eMax },
|
|
{ "Mul", FragmentShadingRateCombinerOpKHR::eMul },
|
|
|
|
};
|
|
|
|
//=== VK_AMD_shader_core_properties2 ===
|
|
|
|
std::unordered_map<std::string, ShaderCorePropertiesFlagBitsAMD> ShaderCorePropertiesFlagBitsAMDEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_validation_features ===
|
|
|
|
std::unordered_map<std::string, ValidationFeatureEnableEXT> ValidationFeatureEnableEXTEntries = {
|
|
{ "GpuAssisted", ValidationFeatureEnableEXT::eGpuAssisted },
|
|
{ "GpuAssistedReserveBindingSlot", ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot },
|
|
{ "BestPractices", ValidationFeatureEnableEXT::eBestPractices },
|
|
{ "DebugPrintf", ValidationFeatureEnableEXT::eDebugPrintf },
|
|
{ "SynchronizationValidation", ValidationFeatureEnableEXT::eSynchronizationValidation },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ValidationFeatureDisableEXT> ValidationFeatureDisableEXTEntries = {
|
|
{ "All", ValidationFeatureDisableEXT::eAll },
|
|
{ "Shaders", ValidationFeatureDisableEXT::eShaders },
|
|
{ "ThreadSafety", ValidationFeatureDisableEXT::eThreadSafety },
|
|
{ "ApiParameters", ValidationFeatureDisableEXT::eApiParameters },
|
|
{ "ObjectLifetimes", ValidationFeatureDisableEXT::eObjectLifetimes },
|
|
{ "CoreChecks", ValidationFeatureDisableEXT::eCoreChecks },
|
|
{ "UniqueHandles", ValidationFeatureDisableEXT::eUniqueHandles },
|
|
{ "ShaderValidationCache", ValidationFeatureDisableEXT::eShaderValidationCache },
|
|
|
|
};
|
|
|
|
//=== VK_NV_coverage_reduction_mode ===
|
|
|
|
std::unordered_map<std::string, CoverageReductionModeNV> CoverageReductionModeNVEntries = {
|
|
{ "Merge", CoverageReductionModeNV::eMerge },
|
|
{ "Truncate", CoverageReductionModeNV::eTruncate },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCoverageReductionStateCreateFlagBitsNV> PipelineCoverageReductionStateCreateFlagBitsNVEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_provoking_vertex ===
|
|
|
|
std::unordered_map<std::string, ProvokingVertexModeEXT> ProvokingVertexModeEXTEntries = {
|
|
{ "FirstVertex", ProvokingVertexModeEXT::eFirstVertex },
|
|
{ "LastVertex", ProvokingVertexModeEXT::eLastVertex },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_EXT_full_screen_exclusive ===
|
|
|
|
std::unordered_map<std::string, FullScreenExclusiveEXT> FullScreenExclusiveEXTEntries = {
|
|
{ "Default", FullScreenExclusiveEXT::eDefault },
|
|
{ "Allowed", FullScreenExclusiveEXT::eAllowed },
|
|
{ "Disallowed", FullScreenExclusiveEXT::eDisallowed },
|
|
{ "ApplicationControlled", FullScreenExclusiveEXT::eApplicationControlled },
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
//=== VK_EXT_headless_surface ===
|
|
|
|
std::unordered_map<std::string, HeadlessSurfaceCreateFlagBitsEXT> HeadlessSurfaceCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_line_rasterization ===
|
|
|
|
std::unordered_map<std::string, LineRasterizationModeEXT> LineRasterizationModeEXTEntries = {
|
|
{ "Default", LineRasterizationModeEXT::eDefault },
|
|
{ "Rectangular", LineRasterizationModeEXT::eRectangular },
|
|
{ "Bresenham", LineRasterizationModeEXT::eBresenham },
|
|
{ "RectangularSmooth", LineRasterizationModeEXT::eRectangularSmooth },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_pipeline_executable_properties ===
|
|
|
|
std::unordered_map<std::string, PipelineExecutableStatisticFormatKHR> PipelineExecutableStatisticFormatKHREntries = {
|
|
{ "Bool32", PipelineExecutableStatisticFormatKHR::eBool32 },
|
|
{ "Int64", PipelineExecutableStatisticFormatKHR::eInt64 },
|
|
{ "Uint64", PipelineExecutableStatisticFormatKHR::eUint64 },
|
|
{ "Float64", PipelineExecutableStatisticFormatKHR::eFloat64 },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_host_image_copy ===
|
|
|
|
std::unordered_map<std::string, HostImageCopyFlagBitsEXT> HostImageCopyFlagBitsEXTEntries = {
|
|
{ "Memcpy", HostImageCopyFlagBitsEXT::eMemcpy },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_map_memory2 ===
|
|
|
|
std::unordered_map<std::string, MemoryUnmapFlagBitsKHR> MemoryUnmapFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_surface_maintenance1 ===
|
|
|
|
std::unordered_map<std::string, PresentScalingFlagBitsEXT> PresentScalingFlagBitsEXTEntries = {
|
|
{ "OneToOne", PresentScalingFlagBitsEXT::eOneToOne },
|
|
{ "AspectRatioStretch", PresentScalingFlagBitsEXT::eAspectRatioStretch },
|
|
{ "Stretch", PresentScalingFlagBitsEXT::eStretch },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PresentGravityFlagBitsEXT> PresentGravityFlagBitsEXTEntries = {
|
|
{ "Min", PresentGravityFlagBitsEXT::eMin },
|
|
{ "Max", PresentGravityFlagBitsEXT::eMax },
|
|
{ "Centered", PresentGravityFlagBitsEXT::eCentered },
|
|
|
|
};
|
|
|
|
//=== VK_NV_device_generated_commands ===
|
|
|
|
std::unordered_map<std::string, IndirectStateFlagBitsNV> IndirectStateFlagBitsNVEntries = {
|
|
{ "FlagFrontface", IndirectStateFlagBitsNV::eFlagFrontface },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, IndirectCommandsTokenTypeNV> IndirectCommandsTokenTypeNVEntries = {
|
|
{ "ShaderGroup", IndirectCommandsTokenTypeNV::eShaderGroup },
|
|
{ "StateFlags", IndirectCommandsTokenTypeNV::eStateFlags },
|
|
{ "IndexBuffer", IndirectCommandsTokenTypeNV::eIndexBuffer },
|
|
{ "VertexBuffer", IndirectCommandsTokenTypeNV::eVertexBuffer },
|
|
{ "PushConstant", IndirectCommandsTokenTypeNV::ePushConstant },
|
|
{ "DrawIndexed", IndirectCommandsTokenTypeNV::eDrawIndexed },
|
|
{ "Draw", IndirectCommandsTokenTypeNV::eDraw },
|
|
{ "DrawTasks", IndirectCommandsTokenTypeNV::eDrawTasks },
|
|
{ "DrawMeshTasks", IndirectCommandsTokenTypeNV::eDrawMeshTasks },
|
|
{ "Pipeline", IndirectCommandsTokenTypeNV::ePipeline },
|
|
{ "Dispatch", IndirectCommandsTokenTypeNV::eDispatch },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, IndirectCommandsLayoutUsageFlagBitsNV> IndirectCommandsLayoutUsageFlagBitsNVEntries = {
|
|
{ "ExplicitPreprocess", IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess },
|
|
{ "IndexedSequences", IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences },
|
|
{ "UnorderedSequences", IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_depth_bias_control ===
|
|
|
|
std::unordered_map<std::string, DepthBiasRepresentationEXT> DepthBiasRepresentationEXTEntries = {
|
|
{ "LeastRepresentableValueFormat", DepthBiasRepresentationEXT::eLeastRepresentableValueFormat },
|
|
{ "LeastRepresentableValueForceUnorm", DepthBiasRepresentationEXT::eLeastRepresentableValueForceUnorm },
|
|
{ "Float", DepthBiasRepresentationEXT::eFloat },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_device_memory_report ===
|
|
|
|
std::unordered_map<std::string, DeviceMemoryReportEventTypeEXT> DeviceMemoryReportEventTypeEXTEntries = {
|
|
{ "Allocate", DeviceMemoryReportEventTypeEXT::eAllocate },
|
|
{ "Free", DeviceMemoryReportEventTypeEXT::eFree },
|
|
{ "Import", DeviceMemoryReportEventTypeEXT::eImport },
|
|
{ "Unimport", DeviceMemoryReportEventTypeEXT::eUnimport },
|
|
{ "AllocationFailed", DeviceMemoryReportEventTypeEXT::eAllocationFailed },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceMemoryReportFlagBitsEXT> DeviceMemoryReportFlagBitsEXTEntries = {
|
|
|
|
};
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_KHR_video_encode_queue ===
|
|
|
|
std::unordered_map<std::string, VideoEncodeCapabilityFlagBitsKHR> VideoEncodeCapabilityFlagBitsKHREntries = {
|
|
{ "PrecedingExternallyEncodedBytes", VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes },
|
|
{ "InsufficientstreamBufferRangeDetectionBit", VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeFeedbackFlagBitsKHR> VideoEncodeFeedbackFlagBitsKHREntries = {
|
|
{ "streamBufferOffsetBit", VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit },
|
|
{ "streamBytesWrittenBit", VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit },
|
|
{ "streamHasOverridesBit", VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeUsageFlagBitsKHR> VideoEncodeUsageFlagBitsKHREntries = {
|
|
{ "Default", VideoEncodeUsageFlagBitsKHR::eDefault }, { "Transcoding", VideoEncodeUsageFlagBitsKHR::eTranscoding },
|
|
{ "Streaming", VideoEncodeUsageFlagBitsKHR::eStreaming }, { "Recording", VideoEncodeUsageFlagBitsKHR::eRecording },
|
|
{ "Conferencing", VideoEncodeUsageFlagBitsKHR::eConferencing },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeContentFlagBitsKHR> VideoEncodeContentFlagBitsKHREntries = {
|
|
{ "Default", VideoEncodeContentFlagBitsKHR::eDefault },
|
|
{ "Camera", VideoEncodeContentFlagBitsKHR::eCamera },
|
|
{ "Desktop", VideoEncodeContentFlagBitsKHR::eDesktop },
|
|
{ "Rendered", VideoEncodeContentFlagBitsKHR::eRendered },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeTuningModeKHR> VideoEncodeTuningModeKHREntries = {
|
|
{ "Default", VideoEncodeTuningModeKHR::eDefault }, { "HighQuality", VideoEncodeTuningModeKHR::eHighQuality },
|
|
{ "LowLatency", VideoEncodeTuningModeKHR::eLowLatency }, { "UltraLowLatency", VideoEncodeTuningModeKHR::eUltraLowLatency },
|
|
{ "Lossless", VideoEncodeTuningModeKHR::eLossless },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeRateControlModeFlagBitsKHR> VideoEncodeRateControlModeFlagBitsKHREntries = {
|
|
{ "Default", VideoEncodeRateControlModeFlagBitsKHR::eDefault },
|
|
{ "Disabled", VideoEncodeRateControlModeFlagBitsKHR::eDisabled },
|
|
{ "Cbr", VideoEncodeRateControlModeFlagBitsKHR::eCbr },
|
|
{ "Vbr", VideoEncodeRateControlModeFlagBitsKHR::eVbr },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeFlagBitsKHR> VideoEncodeFlagBitsKHREntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeRateControlFlagBitsKHR> VideoEncodeRateControlFlagBitsKHREntries = {
|
|
|
|
};
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_NV_device_diagnostics_config ===
|
|
|
|
std::unordered_map<std::string, DeviceDiagnosticsConfigFlagBitsNV> DeviceDiagnosticsConfigFlagBitsNVEntries = {
|
|
{ "EnableShaderDebugInfo", DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo },
|
|
{ "EnableResourceTracking", DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking },
|
|
{ "EnableAutomaticCheckpoints", DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints },
|
|
{ "EnableShaderErrorReporting", DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
//=== VK_EXT_metal_objects ===
|
|
|
|
std::unordered_map<std::string, ExportMetalObjectTypeFlagBitsEXT> ExportMetalObjectTypeFlagBitsEXTEntries = {
|
|
{ "MetalDevice", ExportMetalObjectTypeFlagBitsEXT::eMetalDevice }, { "MetalCommandQueue", ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue },
|
|
{ "MetalBuffer", ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer }, { "MetalTexture", ExportMetalObjectTypeFlagBitsEXT::eMetalTexture },
|
|
{ "MetalIosurface", ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface }, { "MetalSharedEvent", ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent },
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
|
//=== VK_EXT_graphics_pipeline_library ===
|
|
|
|
std::unordered_map<std::string, GraphicsPipelineLibraryFlagBitsEXT> GraphicsPipelineLibraryFlagBitsEXTEntries = {
|
|
{ "VertexInputInterface", GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface },
|
|
{ "PreRasterizationShaders", GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders },
|
|
{ "FragmentShader", GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader },
|
|
{ "FragmentOutputInterface", GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface },
|
|
|
|
};
|
|
|
|
//=== VK_NV_fragment_shading_rate_enums ===
|
|
|
|
std::unordered_map<std::string, FragmentShadingRateNV> FragmentShadingRateNVEntries = {
|
|
{ "1InvocationPerPixel", FragmentShadingRateNV::e1InvocationPerPixel },
|
|
{ "1InvocationPer1X2Pixels", FragmentShadingRateNV::e1InvocationPer1X2Pixels },
|
|
{ "1InvocationPer2X1Pixels", FragmentShadingRateNV::e1InvocationPer2X1Pixels },
|
|
{ "1InvocationPer2X2Pixels", FragmentShadingRateNV::e1InvocationPer2X2Pixels },
|
|
{ "1InvocationPer2X4Pixels", FragmentShadingRateNV::e1InvocationPer2X4Pixels },
|
|
{ "1InvocationPer4X2Pixels", FragmentShadingRateNV::e1InvocationPer4X2Pixels },
|
|
{ "1InvocationPer4X4Pixels", FragmentShadingRateNV::e1InvocationPer4X4Pixels },
|
|
{ "2InvocationsPerPixel", FragmentShadingRateNV::e2InvocationsPerPixel },
|
|
{ "4InvocationsPerPixel", FragmentShadingRateNV::e4InvocationsPerPixel },
|
|
{ "8InvocationsPerPixel", FragmentShadingRateNV::e8InvocationsPerPixel },
|
|
{ "16InvocationsPerPixel", FragmentShadingRateNV::e16InvocationsPerPixel },
|
|
{ "NoInvocations", FragmentShadingRateNV::eNoInvocations },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FragmentShadingRateTypeNV> FragmentShadingRateTypeNVEntries = {
|
|
{ "FragmentSize", FragmentShadingRateTypeNV::eFragmentSize },
|
|
{ "Enums", FragmentShadingRateTypeNV::eEnums },
|
|
|
|
};
|
|
|
|
//=== VK_NV_ray_tracing_motion_blur ===
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMotionInstanceTypeNV> AccelerationStructureMotionInstanceTypeNVEntries = {
|
|
{ "Static", AccelerationStructureMotionInstanceTypeNV::eStatic },
|
|
{ "MatrixMotion", AccelerationStructureMotionInstanceTypeNV::eMatrixMotion },
|
|
{ "SrtMotion", AccelerationStructureMotionInstanceTypeNV::eSrtMotion },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMotionInfoFlagBitsNV> AccelerationStructureMotionInfoFlagBitsNVEntries = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMotionInstanceFlagBitsNV> AccelerationStructureMotionInstanceFlagBitsNVEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_image_compression_control ===
|
|
|
|
std::unordered_map<std::string, ImageCompressionFlagBitsEXT> ImageCompressionFlagBitsEXTEntries = {
|
|
{ "Default", ImageCompressionFlagBitsEXT::eDefault },
|
|
{ "FixedRateDefault", ImageCompressionFlagBitsEXT::eFixedRateDefault },
|
|
{ "FixedRateExplicit", ImageCompressionFlagBitsEXT::eFixedRateExplicit },
|
|
{ "Disabled", ImageCompressionFlagBitsEXT::eDisabled },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageCompressionFixedRateFlagBitsEXT> ImageCompressionFixedRateFlagBitsEXTEntries = {
|
|
{ "None", ImageCompressionFixedRateFlagBitsEXT::eNone }, { "1Bpc", ImageCompressionFixedRateFlagBitsEXT::e1Bpc },
|
|
{ "2Bpc", ImageCompressionFixedRateFlagBitsEXT::e2Bpc }, { "3Bpc", ImageCompressionFixedRateFlagBitsEXT::e3Bpc },
|
|
{ "4Bpc", ImageCompressionFixedRateFlagBitsEXT::e4Bpc }, { "5Bpc", ImageCompressionFixedRateFlagBitsEXT::e5Bpc },
|
|
{ "6Bpc", ImageCompressionFixedRateFlagBitsEXT::e6Bpc }, { "7Bpc", ImageCompressionFixedRateFlagBitsEXT::e7Bpc },
|
|
{ "8Bpc", ImageCompressionFixedRateFlagBitsEXT::e8Bpc }, { "9Bpc", ImageCompressionFixedRateFlagBitsEXT::e9Bpc },
|
|
{ "10Bpc", ImageCompressionFixedRateFlagBitsEXT::e10Bpc }, { "11Bpc", ImageCompressionFixedRateFlagBitsEXT::e11Bpc },
|
|
{ "12Bpc", ImageCompressionFixedRateFlagBitsEXT::e12Bpc }, { "13Bpc", ImageCompressionFixedRateFlagBitsEXT::e13Bpc },
|
|
{ "14Bpc", ImageCompressionFixedRateFlagBitsEXT::e14Bpc }, { "15Bpc", ImageCompressionFixedRateFlagBitsEXT::e15Bpc },
|
|
{ "16Bpc", ImageCompressionFixedRateFlagBitsEXT::e16Bpc }, { "17Bpc", ImageCompressionFixedRateFlagBitsEXT::e17Bpc },
|
|
{ "18Bpc", ImageCompressionFixedRateFlagBitsEXT::e18Bpc }, { "19Bpc", ImageCompressionFixedRateFlagBitsEXT::e19Bpc },
|
|
{ "20Bpc", ImageCompressionFixedRateFlagBitsEXT::e20Bpc }, { "21Bpc", ImageCompressionFixedRateFlagBitsEXT::e21Bpc },
|
|
{ "22Bpc", ImageCompressionFixedRateFlagBitsEXT::e22Bpc }, { "23Bpc", ImageCompressionFixedRateFlagBitsEXT::e23Bpc },
|
|
{ "24Bpc", ImageCompressionFixedRateFlagBitsEXT::e24Bpc },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_device_fault ===
|
|
|
|
std::unordered_map<std::string, DeviceFaultAddressTypeEXT> DeviceFaultAddressTypeEXTEntries = {
|
|
{ "None", DeviceFaultAddressTypeEXT::eNone },
|
|
{ "ReadInvalid", DeviceFaultAddressTypeEXT::eReadInvalid },
|
|
{ "WriteInvalid", DeviceFaultAddressTypeEXT::eWriteInvalid },
|
|
{ "ExecuteInvalid", DeviceFaultAddressTypeEXT::eExecuteInvalid },
|
|
{ "InstructionPointerUnknown", DeviceFaultAddressTypeEXT::eInstructionPointerUnknown },
|
|
{ "InstructionPointerInvalid", DeviceFaultAddressTypeEXT::eInstructionPointerInvalid },
|
|
{ "InstructionPointerFault", DeviceFaultAddressTypeEXT::eInstructionPointerFault },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceFaultVendorBinaryHeaderVersionEXT> DeviceFaultVendorBinaryHeaderVersionEXTEntries = {
|
|
{ "One", DeviceFaultVendorBinaryHeaderVersionEXT::eOne },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
//=== VK_EXT_directfb_surface ===
|
|
|
|
std::unordered_map<std::string, DirectFBSurfaceCreateFlagBitsEXT> DirectFBSurfaceCreateFlagBitsEXTEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
|
//=== VK_EXT_device_address_binding_report ===
|
|
|
|
std::unordered_map<std::string, DeviceAddressBindingFlagBitsEXT> DeviceAddressBindingFlagBitsEXTEntries = {
|
|
{ "InternalObject", DeviceAddressBindingFlagBitsEXT::eInternalObject },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceAddressBindingTypeEXT> DeviceAddressBindingTypeEXTEntries = {
|
|
{ "Bind", DeviceAddressBindingTypeEXT::eBind },
|
|
{ "Unbind", DeviceAddressBindingTypeEXT::eUnbind },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_buffer_collection ===
|
|
|
|
std::unordered_map<std::string, ImageConstraintsInfoFlagBitsFUCHSIA> ImageConstraintsInfoFlagBitsFUCHSIAEntries = {
|
|
{ "CpuReadRarely", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely },
|
|
{ "CpuReadOften", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften },
|
|
{ "CpuWriteRarely", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely },
|
|
{ "CpuWriteOften", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften },
|
|
{ "ProtectedOptional", ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageFormatConstraintsFlagBitsFUCHSIA> ImageFormatConstraintsFlagBitsFUCHSIAEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
//=== VK_EXT_frame_boundary ===
|
|
|
|
std::unordered_map<std::string, FrameBoundaryFlagBitsEXT> FrameBoundaryFlagBitsEXTEntries = {
|
|
{ "FrameEnd", FrameBoundaryFlagBitsEXT::eFrameEnd },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
//=== VK_QNX_screen_surface ===
|
|
|
|
std::unordered_map<std::string, ScreenSurfaceCreateFlagBitsQNX> ScreenSurfaceCreateFlagBitsQNXEntries = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
|
//=== VK_EXT_opacity_micromap ===
|
|
|
|
std::unordered_map<std::string, MicromapTypeEXT> MicromapTypeEXTEntries = {
|
|
{ "OpacityMicromap", MicromapTypeEXT::eOpacityMicromap },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "DisplacementMicromapNV", MicromapTypeEXT::eDisplacementMicromapNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildMicromapFlagBitsEXT> BuildMicromapFlagBitsEXTEntries = {
|
|
{ "PreferFastTrace", BuildMicromapFlagBitsEXT::ePreferFastTrace },
|
|
{ "PreferFastBuild", BuildMicromapFlagBitsEXT::ePreferFastBuild },
|
|
{ "AllowCompaction", BuildMicromapFlagBitsEXT::eAllowCompaction },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CopyMicromapModeEXT> CopyMicromapModeEXTEntries = {
|
|
{ "Clone", CopyMicromapModeEXT::eClone },
|
|
{ "Serialize", CopyMicromapModeEXT::eSerialize },
|
|
{ "Deserialize", CopyMicromapModeEXT::eDeserialize },
|
|
{ "Compact", CopyMicromapModeEXT::eCompact },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MicromapCreateFlagBitsEXT> MicromapCreateFlagBitsEXTEntries = {
|
|
{ "DeviceAddressCaptureReplay", MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildMicromapModeEXT> BuildMicromapModeEXTEntries = {
|
|
{ "Build", BuildMicromapModeEXT::eBuild },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpacityMicromapFormatEXT> OpacityMicromapFormatEXTEntries = {
|
|
{ "2State", OpacityMicromapFormatEXT::e2State },
|
|
{ "4State", OpacityMicromapFormatEXT::e4State },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpacityMicromapSpecialIndexEXT> OpacityMicromapSpecialIndexEXTEntries = {
|
|
{ "FullyTransparent", OpacityMicromapSpecialIndexEXT::eFullyTransparent },
|
|
{ "FullyOpaque", OpacityMicromapSpecialIndexEXT::eFullyOpaque },
|
|
{ "FullyUnknownTransparent", OpacityMicromapSpecialIndexEXT::eFullyUnknownTransparent },
|
|
{ "FullyUnknownOpaque", OpacityMicromapSpecialIndexEXT::eFullyUnknownOpaque },
|
|
|
|
};
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_NV_displacement_micromap ===
|
|
|
|
std::unordered_map<std::string, DisplacementMicromapFormatNV> DisplacementMicromapFormatNVEntries = {
|
|
{ "64Triangles64Bytes", DisplacementMicromapFormatNV::e64Triangles64Bytes },
|
|
{ "256Triangles128Bytes", DisplacementMicromapFormatNV::e256Triangles128Bytes },
|
|
{ "1024Triangles128Bytes", DisplacementMicromapFormatNV::e1024Triangles128Bytes },
|
|
|
|
};
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_ARM_scheduling_controls ===
|
|
|
|
std::unordered_map<std::string, PhysicalDeviceSchedulingControlsFlagBitsARM> PhysicalDeviceSchedulingControlsFlagBitsARMEntries = {
|
|
{ "ShaderCoreCount", PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount },
|
|
|
|
};
|
|
|
|
//=== VK_NV_memory_decompression ===
|
|
|
|
std::unordered_map<std::string, MemoryDecompressionMethodFlagBitsNV> MemoryDecompressionMethodFlagBitsNVEntries = {
|
|
{ "Gdeflate10", MemoryDecompressionMethodFlagBitsNV::eGdeflate10 },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_subpass_merge_feedback ===
|
|
|
|
std::unordered_map<std::string, SubpassMergeStatusEXT> SubpassMergeStatusEXTEntries = {
|
|
{ "Merged", SubpassMergeStatusEXT::eMerged },
|
|
{ "Disallowed", SubpassMergeStatusEXT::eDisallowed },
|
|
{ "NotMergedSideEffects", SubpassMergeStatusEXT::eNotMergedSideEffects },
|
|
{ "NotMergedSamplesMismatch", SubpassMergeStatusEXT::eNotMergedSamplesMismatch },
|
|
{ "NotMergedViewsMismatch", SubpassMergeStatusEXT::eNotMergedViewsMismatch },
|
|
{ "NotMergedAliasing", SubpassMergeStatusEXT::eNotMergedAliasing },
|
|
{ "NotMergedDependencies", SubpassMergeStatusEXT::eNotMergedDependencies },
|
|
{ "NotMergedIncompatibleInputAttachment", SubpassMergeStatusEXT::eNotMergedIncompatibleInputAttachment },
|
|
{ "NotMergedTooManyAttachments", SubpassMergeStatusEXT::eNotMergedTooManyAttachments },
|
|
{ "NotMergedInsufficientStorage", SubpassMergeStatusEXT::eNotMergedInsufficientStorage },
|
|
{ "NotMergedDepthStencilCount", SubpassMergeStatusEXT::eNotMergedDepthStencilCount },
|
|
{ "NotMergedResolveAttachmentReuse", SubpassMergeStatusEXT::eNotMergedResolveAttachmentReuse },
|
|
{ "NotMergedSingleSubpass", SubpassMergeStatusEXT::eNotMergedSingleSubpass },
|
|
{ "NotMergedUnspecified", SubpassMergeStatusEXT::eNotMergedUnspecified },
|
|
|
|
};
|
|
|
|
//=== VK_LUNARG_direct_driver_loading ===
|
|
|
|
std::unordered_map<std::string, DirectDriverLoadingModeLUNARG> DirectDriverLoadingModeLUNARGEntries = {
|
|
{ "Exclusive", DirectDriverLoadingModeLUNARG::eExclusive },
|
|
{ "Inclusive", DirectDriverLoadingModeLUNARG::eInclusive },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DirectDriverLoadingFlagBitsLUNARG> DirectDriverLoadingFlagBitsLUNARGEntries = {
|
|
|
|
};
|
|
|
|
//=== VK_NV_optical_flow ===
|
|
|
|
std::unordered_map<std::string, OpticalFlowUsageFlagBitsNV> OpticalFlowUsageFlagBitsNVEntries = {
|
|
{ "Unknown", OpticalFlowUsageFlagBitsNV::eUnknown }, { "Input", OpticalFlowUsageFlagBitsNV::eInput },
|
|
{ "Output", OpticalFlowUsageFlagBitsNV::eOutput }, { "Hint", OpticalFlowUsageFlagBitsNV::eHint },
|
|
{ "Cost", OpticalFlowUsageFlagBitsNV::eCost }, { "GlobalFlow", OpticalFlowUsageFlagBitsNV::eGlobalFlow },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowGridSizeFlagBitsNV> OpticalFlowGridSizeFlagBitsNVEntries = {
|
|
{ "Unknown", OpticalFlowGridSizeFlagBitsNV::eUnknown }, { "1X1", OpticalFlowGridSizeFlagBitsNV::e1X1 }, { "2X2", OpticalFlowGridSizeFlagBitsNV::e2X2 },
|
|
{ "4X4", OpticalFlowGridSizeFlagBitsNV::e4X4 }, { "8X8", OpticalFlowGridSizeFlagBitsNV::e8X8 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowPerformanceLevelNV> OpticalFlowPerformanceLevelNVEntries = {
|
|
{ "Unknown", OpticalFlowPerformanceLevelNV::eUnknown },
|
|
{ "Slow", OpticalFlowPerformanceLevelNV::eSlow },
|
|
{ "Medium", OpticalFlowPerformanceLevelNV::eMedium },
|
|
{ "Fast", OpticalFlowPerformanceLevelNV::eFast },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowSessionBindingPointNV> OpticalFlowSessionBindingPointNVEntries = {
|
|
{ "Unknown", OpticalFlowSessionBindingPointNV::eUnknown },
|
|
{ "Input", OpticalFlowSessionBindingPointNV::eInput },
|
|
{ "Reference", OpticalFlowSessionBindingPointNV::eReference },
|
|
{ "Hint", OpticalFlowSessionBindingPointNV::eHint },
|
|
{ "FlowVector", OpticalFlowSessionBindingPointNV::eFlowVector },
|
|
{ "BackwardFlowVector", OpticalFlowSessionBindingPointNV::eBackwardFlowVector },
|
|
{ "Cost", OpticalFlowSessionBindingPointNV::eCost },
|
|
{ "BackwardCost", OpticalFlowSessionBindingPointNV::eBackwardCost },
|
|
{ "GlobalFlow", OpticalFlowSessionBindingPointNV::eGlobalFlow },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowSessionCreateFlagBitsNV> OpticalFlowSessionCreateFlagBitsNVEntries = {
|
|
{ "EnableHint", OpticalFlowSessionCreateFlagBitsNV::eEnableHint },
|
|
{ "EnableCost", OpticalFlowSessionCreateFlagBitsNV::eEnableCost },
|
|
{ "EnableGlobalFlow", OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow },
|
|
{ "AllowRegions", OpticalFlowSessionCreateFlagBitsNV::eAllowRegions },
|
|
{ "BothDirections", OpticalFlowSessionCreateFlagBitsNV::eBothDirections },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowExecuteFlagBitsNV> OpticalFlowExecuteFlagBitsNVEntries = {
|
|
{ "DisableTemporalHints", OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_maintenance5 ===
|
|
|
|
std::unordered_map<std::string, PipelineCreateFlagBits2KHR> PipelineCreateFlagBits2KHREntries = {
|
|
{ "DisableOptimization", PipelineCreateFlagBits2KHR::eDisableOptimization },
|
|
{ "AllowDerivatives", PipelineCreateFlagBits2KHR::eAllowDerivatives },
|
|
{ "Derivative", PipelineCreateFlagBits2KHR::eDerivative },
|
|
{ "ViewIndexFromDeviceIndex", PipelineCreateFlagBits2KHR::eViewIndexFromDeviceIndex },
|
|
{ "DispatchBase", PipelineCreateFlagBits2KHR::eDispatchBase },
|
|
{ "DeferCompileNV", PipelineCreateFlagBits2KHR::eDeferCompileNV },
|
|
{ "CaptureStatistics", PipelineCreateFlagBits2KHR::eCaptureStatistics },
|
|
{ "CaptureInternalRepresentations", PipelineCreateFlagBits2KHR::eCaptureInternalRepresentations },
|
|
{ "FailOnPipelineCompileRequired", PipelineCreateFlagBits2KHR::eFailOnPipelineCompileRequired },
|
|
{ "EarlyReturnOnFailure", PipelineCreateFlagBits2KHR::eEarlyReturnOnFailure },
|
|
{ "LinkTimeOptimizationEXT", PipelineCreateFlagBits2KHR::eLinkTimeOptimizationEXT },
|
|
{ "RetainLinkTimeOptimizationInfoEXT", PipelineCreateFlagBits2KHR::eRetainLinkTimeOptimizationInfoEXT },
|
|
{ "Library", PipelineCreateFlagBits2KHR::eLibrary },
|
|
{ "RayTracingSkipTriangles", PipelineCreateFlagBits2KHR::eRayTracingSkipTriangles },
|
|
{ "RayTracingSkipAabbs", PipelineCreateFlagBits2KHR::eRayTracingSkipAabbs },
|
|
{ "RayTracingNoNullAnyHitShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullAnyHitShaders },
|
|
{ "RayTracingNoNullClosestHitShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullClosestHitShaders },
|
|
{ "RayTracingNoNullMissShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullMissShaders },
|
|
{ "RayTracingNoNullIntersectionShaders", PipelineCreateFlagBits2KHR::eRayTracingNoNullIntersectionShaders },
|
|
{ "RayTracingShaderGroupHandleCaptureReplay", PipelineCreateFlagBits2KHR::eRayTracingShaderGroupHandleCaptureReplay },
|
|
{ "IndirectBindableNV", PipelineCreateFlagBits2KHR::eIndirectBindableNV },
|
|
{ "RayTracingAllowMotionNV", PipelineCreateFlagBits2KHR::eRayTracingAllowMotionNV },
|
|
{ "RenderingFragmentShadingRateAttachment", PipelineCreateFlagBits2KHR::eRenderingFragmentShadingRateAttachment },
|
|
{ "RenderingFragmentDensityMapAttachmentEXT", PipelineCreateFlagBits2KHR::eRenderingFragmentDensityMapAttachmentEXT },
|
|
{ "RayTracingOpacityMicromapEXT", PipelineCreateFlagBits2KHR::eRayTracingOpacityMicromapEXT },
|
|
{ "ColorAttachmentFeedbackLoopEXT", PipelineCreateFlagBits2KHR::eColorAttachmentFeedbackLoopEXT },
|
|
{ "DepthStencilAttachmentFeedbackLoopEXT", PipelineCreateFlagBits2KHR::eDepthStencilAttachmentFeedbackLoopEXT },
|
|
{ "NoProtectedAccessEXT", PipelineCreateFlagBits2KHR::eNoProtectedAccessEXT },
|
|
{ "ProtectedAccessOnlyEXT", PipelineCreateFlagBits2KHR::eProtectedAccessOnlyEXT },
|
|
{ "RayTracingDisplacementMicromapNV", PipelineCreateFlagBits2KHR::eRayTracingDisplacementMicromapNV },
|
|
{ "DescriptorBufferEXT", PipelineCreateFlagBits2KHR::eDescriptorBufferEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BufferUsageFlagBits2KHR> BufferUsageFlagBits2KHREntries = {
|
|
{ "TransferSrc", BufferUsageFlagBits2KHR::eTransferSrc },
|
|
{ "TransferDst", BufferUsageFlagBits2KHR::eTransferDst },
|
|
{ "UniformTexelBuffer", BufferUsageFlagBits2KHR::eUniformTexelBuffer },
|
|
{ "StorageTexelBuffer", BufferUsageFlagBits2KHR::eStorageTexelBuffer },
|
|
{ "UniformBuffer", BufferUsageFlagBits2KHR::eUniformBuffer },
|
|
{ "StorageBuffer", BufferUsageFlagBits2KHR::eStorageBuffer },
|
|
{ "IndexBuffer", BufferUsageFlagBits2KHR::eIndexBuffer },
|
|
{ "VertexBuffer", BufferUsageFlagBits2KHR::eVertexBuffer },
|
|
{ "IndirectBuffer", BufferUsageFlagBits2KHR::eIndirectBuffer },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "ExecutionGraphScratchAMDX", BufferUsageFlagBits2KHR::eExecutionGraphScratchAMDX },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "ConditionalRenderingEXT", BufferUsageFlagBits2KHR::eConditionalRenderingEXT },
|
|
{ "ShaderBindingTable", BufferUsageFlagBits2KHR::eShaderBindingTable },
|
|
{ "TransformFeedbackBufferEXT", BufferUsageFlagBits2KHR::eTransformFeedbackBufferEXT },
|
|
{ "TransformFeedbackCounterBufferEXT", BufferUsageFlagBits2KHR::eTransformFeedbackCounterBufferEXT },
|
|
{ "VideoDecodeSrc", BufferUsageFlagBits2KHR::eVideoDecodeSrc },
|
|
{ "VideoDecodeDst", BufferUsageFlagBits2KHR::eVideoDecodeDst },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "VideoEncodeDst", BufferUsageFlagBits2KHR::eVideoEncodeDst },
|
|
{ "VideoEncodeSrc", BufferUsageFlagBits2KHR::eVideoEncodeSrc },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
{ "ShaderDeviceAddress", BufferUsageFlagBits2KHR::eShaderDeviceAddress },
|
|
{ "AccelerationStructureBuildInputReadOnly", BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly },
|
|
{ "AccelerationStructureStorage", BufferUsageFlagBits2KHR::eAccelerationStructureStorage },
|
|
{ "SamplerDescriptorBufferEXT", BufferUsageFlagBits2KHR::eSamplerDescriptorBufferEXT },
|
|
{ "ResourceDescriptorBufferEXT", BufferUsageFlagBits2KHR::eResourceDescriptorBufferEXT },
|
|
{ "PushDescriptorsDescriptorBufferEXT", BufferUsageFlagBits2KHR::ePushDescriptorsDescriptorBufferEXT },
|
|
{ "MicromapBuildInputReadOnlyEXT", BufferUsageFlagBits2KHR::eMicromapBuildInputReadOnlyEXT },
|
|
{ "MicromapStorageEXT", BufferUsageFlagBits2KHR::eMicromapStorageEXT },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_shader_object ===
|
|
|
|
std::unordered_map<std::string, ShaderCreateFlagBitsEXT> ShaderCreateFlagBitsEXTEntries = {
|
|
{ "LinkStage", ShaderCreateFlagBitsEXT::eLinkStage },
|
|
{ "AllowVaryingSubgroupSize", ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize },
|
|
{ "RequireFullSubgroups", ShaderCreateFlagBitsEXT::eRequireFullSubgroups },
|
|
{ "NoTaskShader", ShaderCreateFlagBitsEXT::eNoTaskShader },
|
|
{ "DispatchBase", ShaderCreateFlagBitsEXT::eDispatchBase },
|
|
{ "FragmentShadingRateAttachment", ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment },
|
|
{ "FragmentDensityMapAttachment", ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ShaderCodeTypeEXT> ShaderCodeTypeEXTEntries = {
|
|
{ "Binary", ShaderCodeTypeEXT::eBinary },
|
|
{ "Spirv", ShaderCodeTypeEXT::eSpirv },
|
|
|
|
};
|
|
|
|
//=== VK_NV_ray_tracing_invocation_reorder ===
|
|
|
|
std::unordered_map<std::string, RayTracingInvocationReorderModeNV> RayTracingInvocationReorderModeNVEntries = {
|
|
{ "None", RayTracingInvocationReorderModeNV::eNone },
|
|
{ "Reorder", RayTracingInvocationReorderModeNV::eReorder },
|
|
|
|
};
|
|
|
|
//=== VK_NV_low_latency2 ===
|
|
|
|
std::unordered_map<std::string, LatencyMarkerNV> LatencyMarkerNVEntries = {
|
|
{ "SimulationStart", LatencyMarkerNV::eSimulationStart },
|
|
{ "SimulationEnd", LatencyMarkerNV::eSimulationEnd },
|
|
{ "RendersubmitStart", LatencyMarkerNV::eRendersubmitStart },
|
|
{ "RendersubmitEnd", LatencyMarkerNV::eRendersubmitEnd },
|
|
{ "PresentStart", LatencyMarkerNV::ePresentStart },
|
|
{ "PresentEnd", LatencyMarkerNV::ePresentEnd },
|
|
{ "InputSample", LatencyMarkerNV::eInputSample },
|
|
{ "TriggerFlash", LatencyMarkerNV::eTriggerFlash },
|
|
{ "OutOfBandRendersubmitStart", LatencyMarkerNV::eOutOfBandRendersubmitStart },
|
|
{ "OutOfBandRendersubmitEnd", LatencyMarkerNV::eOutOfBandRendersubmitEnd },
|
|
{ "OutOfBandPresentStart", LatencyMarkerNV::eOutOfBandPresentStart },
|
|
{ "OutOfBandPresentEnd", LatencyMarkerNV::eOutOfBandPresentEnd },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OutOfBandQueueTypeNV> OutOfBandQueueTypeNVEntries = {
|
|
{ "Render", OutOfBandQueueTypeNV::eRender },
|
|
{ "Present", OutOfBandQueueTypeNV::ePresent },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_cooperative_matrix ===
|
|
|
|
std::unordered_map<std::string, ScopeKHR> ScopeKHREntries = {
|
|
{ "Device", ScopeKHR::eDevice },
|
|
{ "Workgroup", ScopeKHR::eWorkgroup },
|
|
{ "Subgroup", ScopeKHR::eSubgroup },
|
|
{ "QueueFamily", ScopeKHR::eQueueFamily },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ComponentTypeKHR> ComponentTypeKHREntries = {
|
|
{ "Float16", ComponentTypeKHR::eFloat16 }, { "Float32", ComponentTypeKHR::eFloat32 }, { "Float64", ComponentTypeKHR::eFloat64 },
|
|
{ "Sint8", ComponentTypeKHR::eSint8 }, { "Sint16", ComponentTypeKHR::eSint16 }, { "Sint32", ComponentTypeKHR::eSint32 },
|
|
{ "Sint64", ComponentTypeKHR::eSint64 }, { "Uint8", ComponentTypeKHR::eUint8 }, { "Uint16", ComponentTypeKHR::eUint16 },
|
|
{ "Uint32", ComponentTypeKHR::eUint32 }, { "Uint64", ComponentTypeKHR::eUint64 },
|
|
|
|
};
|
|
|
|
//=== VK_QCOM_image_processing2 ===
|
|
|
|
std::unordered_map<std::string, BlockMatchWindowCompareModeQCOM> BlockMatchWindowCompareModeQCOMEntries = {
|
|
{ "Min", BlockMatchWindowCompareModeQCOM::eMin },
|
|
{ "Max", BlockMatchWindowCompareModeQCOM::eMax },
|
|
|
|
};
|
|
|
|
//=== VK_QCOM_filter_cubic_weights ===
|
|
|
|
std::unordered_map<std::string, CubicFilterWeightsQCOM> CubicFilterWeightsQCOMEntries = {
|
|
{ "CatmullRom", CubicFilterWeightsQCOM::eCatmullRom },
|
|
{ "ZeroTangentCardinal", CubicFilterWeightsQCOM::eZeroTangentCardinal },
|
|
{ "BSpline", CubicFilterWeightsQCOM::eBSpline },
|
|
{ "MitchellNetravali", CubicFilterWeightsQCOM::eMitchellNetravali },
|
|
|
|
};
|
|
|
|
//=== VK_MSFT_layered_driver ===
|
|
|
|
std::unordered_map<std::string, LayeredDriverUnderlyingApiMSFT> LayeredDriverUnderlyingApiMSFTEntries = {
|
|
{ "None", LayeredDriverUnderlyingApiMSFT::eNone },
|
|
{ "D3D12", LayeredDriverUnderlyingApiMSFT::eD3D12 },
|
|
|
|
};
|
|
};
|
|
|
|
VULKAN_HPP_STORAGE_API extern const EnumFromStringMap enumFromStringMap;
|
|
|
|
template <typename TEnum>
|
|
std::optional<TEnum> from_string( const std::string & );
|
|
|
|
//=== VK_VERSION_1_0 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<Result> from_string<Result>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ResultEntries.find( value );
|
|
if ( it != enumFromStringMap.ResultEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<StructureType> from_string<StructureType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.StructureTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.StructureTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCacheHeaderVersion> from_string<PipelineCacheHeaderVersion>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCacheHeaderVersionEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineCacheHeaderVersionEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ObjectType> from_string<ObjectType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ObjectTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.ObjectTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VendorId> from_string<VendorId>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VendorIdEntries.find( value );
|
|
if ( it != enumFromStringMap.VendorIdEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<Format> from_string<Format>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FormatEntries.find( value );
|
|
if ( it != enumFromStringMap.FormatEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FormatFeatureFlagBits> from_string<FormatFeatureFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FormatFeatureFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.FormatFeatureFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageCreateFlagBits> from_string<ImageCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageTiling> from_string<ImageTiling>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageTilingEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageTilingEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageType> from_string<ImageType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageUsageFlagBits> from_string<ImageUsageFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageUsageFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageUsageFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<InstanceCreateFlagBits> from_string<InstanceCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.InstanceCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.InstanceCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<InternalAllocationType> from_string<InternalAllocationType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.InternalAllocationTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.InternalAllocationTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MemoryHeapFlagBits> from_string<MemoryHeapFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryHeapFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.MemoryHeapFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MemoryPropertyFlagBits> from_string<MemoryPropertyFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryPropertyFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.MemoryPropertyFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PhysicalDeviceType> from_string<PhysicalDeviceType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PhysicalDeviceTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.PhysicalDeviceTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueueFlagBits> from_string<QueueFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueueFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.QueueFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SampleCountFlagBits> from_string<SampleCountFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SampleCountFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SampleCountFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SystemAllocationScope> from_string<SystemAllocationScope>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SystemAllocationScopeEntries.find( value );
|
|
if ( it != enumFromStringMap.SystemAllocationScopeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceCreateFlagBits> from_string<DeviceCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceQueueCreateFlagBits> from_string<DeviceQueueCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceQueueCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceQueueCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineStageFlagBits> from_string<PipelineStageFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineStageFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineStageFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MemoryMapFlagBits> from_string<MemoryMapFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageAspectFlagBits> from_string<ImageAspectFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageAspectFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageAspectFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SparseImageFormatFlagBits> from_string<SparseImageFormatFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SparseImageFormatFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SparseImageFormatFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SparseMemoryBindFlagBits> from_string<SparseMemoryBindFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SparseMemoryBindFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SparseMemoryBindFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FenceCreateFlagBits> from_string<FenceCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FenceCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.FenceCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreCreateFlagBits> from_string<SemaphoreCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<EventCreateFlagBits> from_string<EventCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.EventCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.EventCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueryPipelineStatisticFlagBits> from_string<QueryPipelineStatisticFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryPipelineStatisticFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.QueryPipelineStatisticFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueryResultFlagBits> from_string<QueryResultFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryResultFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.QueryResultFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueryType> from_string<QueryType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.QueryTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueryPoolCreateFlagBits> from_string<QueryPoolCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BufferCreateFlagBits> from_string<BufferCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BufferCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.BufferCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BufferUsageFlagBits> from_string<BufferUsageFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BufferUsageFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.BufferUsageFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SharingMode> from_string<SharingMode>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SharingModeEntries.find( value );
|
|
if ( it != enumFromStringMap.SharingModeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BufferViewCreateFlagBits> from_string<BufferViewCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageLayout> from_string<ImageLayout>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageLayoutEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageLayoutEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ComponentSwizzle> from_string<ComponentSwizzle>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ComponentSwizzleEntries.find( value );
|
|
if ( it != enumFromStringMap.ComponentSwizzleEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageViewCreateFlagBits> from_string<ImageViewCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageViewCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageViewCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageViewType> from_string<ImageViewType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageViewTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageViewTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderModuleCreateFlagBits> from_string<ShaderModuleCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCacheCreateFlagBits> from_string<PipelineCacheCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCacheCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineCacheCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BlendFactor> from_string<BlendFactor>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlendFactorEntries.find( value );
|
|
if ( it != enumFromStringMap.BlendFactorEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BlendOp> from_string<BlendOp>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlendOpEntries.find( value );
|
|
if ( it != enumFromStringMap.BlendOpEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ColorComponentFlagBits> from_string<ColorComponentFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ColorComponentFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ColorComponentFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CompareOp> from_string<CompareOp>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CompareOpEntries.find( value );
|
|
if ( it != enumFromStringMap.CompareOpEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CullModeFlagBits> from_string<CullModeFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CullModeFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.CullModeFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DynamicState> from_string<DynamicState>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DynamicStateEntries.find( value );
|
|
if ( it != enumFromStringMap.DynamicStateEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FrontFace> from_string<FrontFace>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FrontFaceEntries.find( value );
|
|
if ( it != enumFromStringMap.FrontFaceEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<LogicOp> from_string<LogicOp>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LogicOpEntries.find( value );
|
|
if ( it != enumFromStringMap.LogicOpEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCreateFlagBits> from_string<PipelineCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineShaderStageCreateFlagBits> from_string<PipelineShaderStageCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineShaderStageCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineShaderStageCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PolygonMode> from_string<PolygonMode>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PolygonModeEntries.find( value );
|
|
if ( it != enumFromStringMap.PolygonModeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PrimitiveTopology> from_string<PrimitiveTopology>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PrimitiveTopologyEntries.find( value );
|
|
if ( it != enumFromStringMap.PrimitiveTopologyEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderStageFlagBits> from_string<ShaderStageFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderStageFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ShaderStageFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<StencilOp> from_string<StencilOp>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.StencilOpEntries.find( value );
|
|
if ( it != enumFromStringMap.StencilOpEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VertexInputRate> from_string<VertexInputRate>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VertexInputRateEntries.find( value );
|
|
if ( it != enumFromStringMap.VertexInputRateEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineColorBlendStateCreateFlagBits> from_string<PipelineColorBlendStateCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineColorBlendStateCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineColorBlendStateCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineDepthStencilStateCreateFlagBits> from_string<PipelineDepthStencilStateCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineDepthStencilStateCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineDepthStencilStateCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineDynamicStateCreateFlagBits> from_string<PipelineDynamicStateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineInputAssemblyStateCreateFlagBits> from_string<PipelineInputAssemblyStateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineLayoutCreateFlagBits> from_string<PipelineLayoutCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineLayoutCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineLayoutCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineMultisampleStateCreateFlagBits> from_string<PipelineMultisampleStateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationStateCreateFlagBits> from_string<PipelineRasterizationStateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineTessellationStateCreateFlagBits> from_string<PipelineTessellationStateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineVertexInputStateCreateFlagBits> from_string<PipelineVertexInputStateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineViewportStateCreateFlagBits> from_string<PipelineViewportStateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BorderColor> from_string<BorderColor>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BorderColorEntries.find( value );
|
|
if ( it != enumFromStringMap.BorderColorEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<Filter> from_string<Filter>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FilterEntries.find( value );
|
|
if ( it != enumFromStringMap.FilterEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SamplerAddressMode> from_string<SamplerAddressMode>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerAddressModeEntries.find( value );
|
|
if ( it != enumFromStringMap.SamplerAddressModeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SamplerCreateFlagBits> from_string<SamplerCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SamplerCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SamplerMipmapMode> from_string<SamplerMipmapMode>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerMipmapModeEntries.find( value );
|
|
if ( it != enumFromStringMap.SamplerMipmapModeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DescriptorPoolCreateFlagBits> from_string<DescriptorPoolCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorPoolCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.DescriptorPoolCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DescriptorSetLayoutCreateFlagBits> from_string<DescriptorSetLayoutCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorSetLayoutCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.DescriptorSetLayoutCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DescriptorType> from_string<DescriptorType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.DescriptorTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DescriptorPoolResetFlagBits> from_string<DescriptorPoolResetFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccessFlagBits> from_string<AccessFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccessFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.AccessFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AttachmentDescriptionFlagBits> from_string<AttachmentDescriptionFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AttachmentDescriptionFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.AttachmentDescriptionFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AttachmentLoadOp> from_string<AttachmentLoadOp>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AttachmentLoadOpEntries.find( value );
|
|
if ( it != enumFromStringMap.AttachmentLoadOpEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AttachmentStoreOp> from_string<AttachmentStoreOp>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AttachmentStoreOpEntries.find( value );
|
|
if ( it != enumFromStringMap.AttachmentStoreOpEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DependencyFlagBits> from_string<DependencyFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DependencyFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.DependencyFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FramebufferCreateFlagBits> from_string<FramebufferCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FramebufferCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.FramebufferCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineBindPoint> from_string<PipelineBindPoint>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineBindPointEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineBindPointEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<RenderPassCreateFlagBits> from_string<RenderPassCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RenderPassCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.RenderPassCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SubpassDescriptionFlagBits> from_string<SubpassDescriptionFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubpassDescriptionFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SubpassDescriptionFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CommandPoolCreateFlagBits> from_string<CommandPoolCreateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandPoolCreateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.CommandPoolCreateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CommandPoolResetFlagBits> from_string<CommandPoolResetFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandPoolResetFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.CommandPoolResetFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CommandBufferLevel> from_string<CommandBufferLevel>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandBufferLevelEntries.find( value );
|
|
if ( it != enumFromStringMap.CommandBufferLevelEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CommandBufferResetFlagBits> from_string<CommandBufferResetFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandBufferResetFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.CommandBufferResetFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CommandBufferUsageFlagBits> from_string<CommandBufferUsageFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandBufferUsageFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.CommandBufferUsageFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueryControlFlagBits> from_string<QueryControlFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryControlFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.QueryControlFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<IndexType> from_string<IndexType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndexTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.IndexTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<StencilFaceFlagBits> from_string<StencilFaceFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.StencilFaceFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.StencilFaceFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SubpassContents> from_string<SubpassContents>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubpassContentsEntries.find( value );
|
|
if ( it != enumFromStringMap.SubpassContentsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_VERSION_1_1 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SubgroupFeatureFlagBits> from_string<SubgroupFeatureFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubgroupFeatureFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SubgroupFeatureFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PeerMemoryFeatureFlagBits> from_string<PeerMemoryFeatureFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PeerMemoryFeatureFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PeerMemoryFeatureFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MemoryAllocateFlagBits> from_string<MemoryAllocateFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryAllocateFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.MemoryAllocateFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CommandPoolTrimFlagBits> from_string<CommandPoolTrimFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PointClippingBehavior> from_string<PointClippingBehavior>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PointClippingBehaviorEntries.find( value );
|
|
if ( it != enumFromStringMap.PointClippingBehaviorEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<TessellationDomainOrigin> from_string<TessellationDomainOrigin>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.TessellationDomainOriginEntries.find( value );
|
|
if ( it != enumFromStringMap.TessellationDomainOriginEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SamplerYcbcrModelConversion> from_string<SamplerYcbcrModelConversion>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerYcbcrModelConversionEntries.find( value );
|
|
if ( it != enumFromStringMap.SamplerYcbcrModelConversionEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SamplerYcbcrRange> from_string<SamplerYcbcrRange>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerYcbcrRangeEntries.find( value );
|
|
if ( it != enumFromStringMap.SamplerYcbcrRangeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ChromaLocation> from_string<ChromaLocation>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ChromaLocationEntries.find( value );
|
|
if ( it != enumFromStringMap.ChromaLocationEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DescriptorUpdateTemplateType> from_string<DescriptorUpdateTemplateType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorUpdateTemplateTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.DescriptorUpdateTemplateTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DescriptorUpdateTemplateCreateFlagBits> from_string<DescriptorUpdateTemplateCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryHandleTypeFlagBits> from_string<ExternalMemoryHandleTypeFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryHandleTypeFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryHandleTypeFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryFeatureFlagBits> from_string<ExternalMemoryFeatureFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryFeatureFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryFeatureFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalFenceHandleTypeFlagBits> from_string<ExternalFenceHandleTypeFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalFenceHandleTypeFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalFenceHandleTypeFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalFenceFeatureFlagBits> from_string<ExternalFenceFeatureFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalFenceFeatureFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalFenceFeatureFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FenceImportFlagBits> from_string<FenceImportFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FenceImportFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.FenceImportFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreImportFlagBits> from_string<SemaphoreImportFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SemaphoreImportFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SemaphoreImportFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalSemaphoreHandleTypeFlagBits> from_string<ExternalSemaphoreHandleTypeFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalSemaphoreHandleTypeFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalSemaphoreHandleTypeFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalSemaphoreFeatureFlagBits> from_string<ExternalSemaphoreFeatureFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalSemaphoreFeatureFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalSemaphoreFeatureFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_VERSION_1_2 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DriverId> from_string<DriverId>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DriverIdEntries.find( value );
|
|
if ( it != enumFromStringMap.DriverIdEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderFloatControlsIndependence> from_string<ShaderFloatControlsIndependence>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderFloatControlsIndependenceEntries.find( value );
|
|
if ( it != enumFromStringMap.ShaderFloatControlsIndependenceEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DescriptorBindingFlagBits> from_string<DescriptorBindingFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorBindingFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.DescriptorBindingFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ResolveModeFlagBits> from_string<ResolveModeFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ResolveModeFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ResolveModeFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SamplerReductionMode> from_string<SamplerReductionMode>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerReductionModeEntries.find( value );
|
|
if ( it != enumFromStringMap.SamplerReductionModeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreType> from_string<SemaphoreType>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SemaphoreTypeEntries.find( value );
|
|
if ( it != enumFromStringMap.SemaphoreTypeEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreWaitFlagBits> from_string<SemaphoreWaitFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SemaphoreWaitFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SemaphoreWaitFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_VERSION_1_3 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCreationFeedbackFlagBits> from_string<PipelineCreationFeedbackFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCreationFeedbackFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineCreationFeedbackFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ToolPurposeFlagBits> from_string<ToolPurposeFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ToolPurposeFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.ToolPurposeFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PrivateDataSlotCreateFlagBits> from_string<PrivateDataSlotCreateFlagBits>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineStageFlagBits2> from_string<PipelineStageFlagBits2>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineStageFlagBits2Entries.find( value );
|
|
if ( it != enumFromStringMap.PipelineStageFlagBits2Entries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccessFlagBits2> from_string<AccessFlagBits2>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccessFlagBits2Entries.find( value );
|
|
if ( it != enumFromStringMap.AccessFlagBits2Entries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SubmitFlagBits> from_string<SubmitFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubmitFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.SubmitFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<RenderingFlagBits> from_string<RenderingFlagBits>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RenderingFlagBitsEntries.find( value );
|
|
if ( it != enumFromStringMap.RenderingFlagBitsEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FormatFeatureFlagBits2> from_string<FormatFeatureFlagBits2>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FormatFeatureFlagBits2Entries.find( value );
|
|
if ( it != enumFromStringMap.FormatFeatureFlagBits2Entries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SurfaceTransformFlagBitsKHR> from_string<SurfaceTransformFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SurfaceTransformFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.SurfaceTransformFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PresentModeKHR> from_string<PresentModeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PresentModeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.PresentModeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ColorSpaceKHR> from_string<ColorSpaceKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ColorSpaceKHREntries.find( value );
|
|
if ( it != enumFromStringMap.ColorSpaceKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CompositeAlphaFlagBitsKHR> from_string<CompositeAlphaFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CompositeAlphaFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.CompositeAlphaFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_swapchain ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SwapchainCreateFlagBitsKHR> from_string<SwapchainCreateFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SwapchainCreateFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.SwapchainCreateFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceGroupPresentModeFlagBitsKHR> from_string<DeviceGroupPresentModeFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceGroupPresentModeFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceGroupPresentModeFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_display ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DisplayPlaneAlphaFlagBitsKHR> from_string<DisplayPlaneAlphaFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplayPlaneAlphaFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.DisplayPlaneAlphaFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DisplayModeCreateFlagBitsKHR> from_string<DisplayModeCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DisplaySurfaceCreateFlagBitsKHR> from_string<DisplaySurfaceCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
//=== VK_KHR_xlib_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<XlibSurfaceCreateFlagBitsKHR> from_string<XlibSurfaceCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
//=== VK_KHR_xcb_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<XcbSurfaceCreateFlagBitsKHR> from_string<XcbSurfaceCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
//=== VK_KHR_wayland_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<WaylandSurfaceCreateFlagBitsKHR> from_string<WaylandSurfaceCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
//=== VK_KHR_android_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AndroidSurfaceCreateFlagBitsKHR> from_string<AndroidSurfaceCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_KHR_win32_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<Win32SurfaceCreateFlagBitsKHR> from_string<Win32SurfaceCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
//=== VK_EXT_debug_report ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DebugReportFlagBitsEXT> from_string<DebugReportFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugReportFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DebugReportFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DebugReportObjectTypeEXT> from_string<DebugReportObjectTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugReportObjectTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DebugReportObjectTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_rasterization_order ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<RasterizationOrderAMD> from_string<RasterizationOrderAMD>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RasterizationOrderAMDEntries.find( value );
|
|
if ( it != enumFromStringMap.RasterizationOrderAMDEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_video_queue ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoCodecOperationFlagBitsKHR> from_string<VideoCodecOperationFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoCodecOperationFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoCodecOperationFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoChromaSubsamplingFlagBitsKHR> from_string<VideoChromaSubsamplingFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoChromaSubsamplingFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoChromaSubsamplingFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoComponentBitDepthFlagBitsKHR> from_string<VideoComponentBitDepthFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoComponentBitDepthFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoComponentBitDepthFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoCapabilityFlagBitsKHR> from_string<VideoCapabilityFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoCapabilityFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoCapabilityFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoSessionCreateFlagBitsKHR> from_string<VideoSessionCreateFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoSessionCreateFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoSessionCreateFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoCodingControlFlagBitsKHR> from_string<VideoCodingControlFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoCodingControlFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoCodingControlFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueryResultStatusKHR> from_string<QueryResultStatusKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryResultStatusKHREntries.find( value );
|
|
if ( it != enumFromStringMap.QueryResultStatusKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoSessionParametersCreateFlagBitsKHR> from_string<VideoSessionParametersCreateFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoBeginCodingFlagBitsKHR> from_string<VideoBeginCodingFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEndCodingFlagBitsKHR> from_string<VideoEndCodingFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_video_decode_queue ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeCapabilityFlagBitsKHR> from_string<VideoDecodeCapabilityFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoDecodeCapabilityFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoDecodeCapabilityFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeUsageFlagBitsKHR> from_string<VideoDecodeUsageFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoDecodeUsageFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoDecodeUsageFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeFlagBitsKHR> from_string<VideoDecodeFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_transform_feedback ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationStateStreamCreateFlagBitsEXT>
|
|
from_string<PipelineRasterizationStateStreamCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_EXT_video_encode_h264 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH264CapabilityFlagBitsEXT> from_string<VideoEncodeH264CapabilityFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH264CapabilityFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH264CapabilityFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH264StdFlagBitsEXT> from_string<VideoEncodeH264StdFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH264StdFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH264StdFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH264RateControlFlagBitsEXT> from_string<VideoEncodeH264RateControlFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH264RateControlFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH264RateControlFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_EXT_video_encode_h265 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265CapabilityFlagBitsEXT> from_string<VideoEncodeH265CapabilityFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265CapabilityFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265CapabilityFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265StdFlagBitsEXT> from_string<VideoEncodeH265StdFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265StdFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265StdFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265CtbSizeFlagBitsEXT> from_string<VideoEncodeH265CtbSizeFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265CtbSizeFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265CtbSizeFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265TransformBlockSizeFlagBitsEXT>
|
|
from_string<VideoEncodeH265TransformBlockSizeFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265TransformBlockSizeFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265TransformBlockSizeFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265RateControlFlagBitsEXT> from_string<VideoEncodeH265RateControlFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265RateControlFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265RateControlFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_KHR_video_decode_h264 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeH264PictureLayoutFlagBitsKHR> from_string<VideoDecodeH264PictureLayoutFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoDecodeH264PictureLayoutFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoDecodeH264PictureLayoutFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_shader_info ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderInfoTypeAMD> from_string<ShaderInfoTypeAMD>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderInfoTypeAMDEntries.find( value );
|
|
if ( it != enumFromStringMap.ShaderInfoTypeAMDEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_GGP )
|
|
//=== VK_GGP_stream_descriptor_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<StreamDescriptorSurfaceCreateFlagBitsGGP> from_string<StreamDescriptorSurfaceCreateFlagBitsGGP>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_GGP*/
|
|
|
|
//=== VK_NV_external_memory_capabilities ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryHandleTypeFlagBitsNV> from_string<ExternalMemoryHandleTypeFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryHandleTypeFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryHandleTypeFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryFeatureFlagBitsNV> from_string<ExternalMemoryFeatureFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryFeatureFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryFeatureFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_validation_flags ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ValidationCheckEXT> from_string<ValidationCheckEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationCheckEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ValidationCheckEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_VI_NN )
|
|
//=== VK_NN_vi_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ViSurfaceCreateFlagBitsNN> from_string<ViSurfaceCreateFlagBitsNN>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
|
//=== VK_EXT_pipeline_robustness ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineRobustnessBufferBehaviorEXT> from_string<PipelineRobustnessBufferBehaviorEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineRobustnessBufferBehaviorEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineRobustnessBufferBehaviorEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineRobustnessImageBehaviorEXT> from_string<PipelineRobustnessImageBehaviorEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineRobustnessImageBehaviorEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineRobustnessImageBehaviorEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_conditional_rendering ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ConditionalRenderingFlagBitsEXT> from_string<ConditionalRenderingFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ConditionalRenderingFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ConditionalRenderingFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_display_surface_counter ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SurfaceCounterFlagBitsEXT> from_string<SurfaceCounterFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SurfaceCounterFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.SurfaceCounterFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_display_control ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DisplayPowerStateEXT> from_string<DisplayPowerStateEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplayPowerStateEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DisplayPowerStateEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceEventTypeEXT> from_string<DeviceEventTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceEventTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceEventTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DisplayEventTypeEXT> from_string<DisplayEventTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplayEventTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DisplayEventTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_viewport_swizzle ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ViewportCoordinateSwizzleNV> from_string<ViewportCoordinateSwizzleNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ViewportCoordinateSwizzleNVEntries.find( value );
|
|
if ( it != enumFromStringMap.ViewportCoordinateSwizzleNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineViewportSwizzleStateCreateFlagBitsNV> from_string<PipelineViewportSwizzleStateCreateFlagBitsNV>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_discard_rectangles ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DiscardRectangleModeEXT> from_string<DiscardRectangleModeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DiscardRectangleModeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DiscardRectangleModeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineDiscardRectangleStateCreateFlagBitsEXT>
|
|
from_string<PipelineDiscardRectangleStateCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_conservative_rasterization ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ConservativeRasterizationModeEXT> from_string<ConservativeRasterizationModeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ConservativeRasterizationModeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ConservativeRasterizationModeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationConservativeStateCreateFlagBitsEXT>
|
|
from_string<PipelineRasterizationConservativeStateCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_depth_clip_enable ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationDepthClipStateCreateFlagBitsEXT>
|
|
from_string<PipelineRasterizationDepthClipStateCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_performance_query ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterDescriptionFlagBitsKHR> from_string<PerformanceCounterDescriptionFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterDescriptionFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterDescriptionFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterScopeKHR> from_string<PerformanceCounterScopeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterScopeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterScopeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterStorageKHR> from_string<PerformanceCounterStorageKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterStorageKHREntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterStorageKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterUnitKHR> from_string<PerformanceCounterUnitKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterUnitKHREntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterUnitKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AcquireProfilingLockFlagBitsKHR> from_string<AcquireProfilingLockFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
//=== VK_MVK_ios_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<IOSSurfaceCreateFlagBitsMVK> from_string<IOSSurfaceCreateFlagBitsMVK>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
|
#if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
//=== VK_MVK_macos_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MacOSSurfaceCreateFlagBitsMVK> from_string<MacOSSurfaceCreateFlagBitsMVK>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
|
//=== VK_EXT_debug_utils ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessageSeverityFlagBitsEXT> from_string<DebugUtilsMessageSeverityFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugUtilsMessageSeverityFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DebugUtilsMessageSeverityFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessageTypeFlagBitsEXT> from_string<DebugUtilsMessageTypeFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugUtilsMessageTypeFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DebugUtilsMessageTypeFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessengerCallbackDataFlagBitsEXT> from_string<DebugUtilsMessengerCallbackDataFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessengerCreateFlagBitsEXT> from_string<DebugUtilsMessengerCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_blend_operation_advanced ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BlendOverlapEXT> from_string<BlendOverlapEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlendOverlapEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.BlendOverlapEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_fragment_coverage_to_color ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCoverageToColorStateCreateFlagBitsNV> from_string<PipelineCoverageToColorStateCreateFlagBitsNV>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_acceleration_structure ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureTypeKHR> from_string<AccelerationStructureTypeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureTypeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureTypeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureBuildTypeKHR> from_string<AccelerationStructureBuildTypeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureBuildTypeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureBuildTypeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<GeometryFlagBitsKHR> from_string<GeometryFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GeometryFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.GeometryFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<GeometryInstanceFlagBitsKHR> from_string<GeometryInstanceFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GeometryInstanceFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.GeometryInstanceFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BuildAccelerationStructureFlagBitsKHR> from_string<BuildAccelerationStructureFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildAccelerationStructureFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.BuildAccelerationStructureFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CopyAccelerationStructureModeKHR> from_string<CopyAccelerationStructureModeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CopyAccelerationStructureModeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.CopyAccelerationStructureModeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<GeometryTypeKHR> from_string<GeometryTypeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GeometryTypeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.GeometryTypeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureCompatibilityKHR> from_string<AccelerationStructureCompatibilityKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureCompatibilityKHREntries.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureCompatibilityKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureCreateFlagBitsKHR> from_string<AccelerationStructureCreateFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureCreateFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureCreateFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BuildAccelerationStructureModeKHR> from_string<BuildAccelerationStructureModeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildAccelerationStructureModeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.BuildAccelerationStructureModeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_ray_tracing_pipeline ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<RayTracingShaderGroupTypeKHR> from_string<RayTracingShaderGroupTypeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RayTracingShaderGroupTypeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.RayTracingShaderGroupTypeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderGroupShaderKHR> from_string<ShaderGroupShaderKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderGroupShaderKHREntries.find( value );
|
|
if ( it != enumFromStringMap.ShaderGroupShaderKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_framebuffer_mixed_samples ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CoverageModulationModeNV> from_string<CoverageModulationModeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CoverageModulationModeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.CoverageModulationModeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCoverageModulationStateCreateFlagBitsNV>
|
|
from_string<PipelineCoverageModulationStateCreateFlagBitsNV>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_validation_cache ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ValidationCacheHeaderVersionEXT> from_string<ValidationCacheHeaderVersionEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationCacheHeaderVersionEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ValidationCacheHeaderVersionEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ValidationCacheCreateFlagBitsEXT> from_string<ValidationCacheCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_shading_rate_image ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShadingRatePaletteEntryNV> from_string<ShadingRatePaletteEntryNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShadingRatePaletteEntryNVEntries.find( value );
|
|
if ( it != enumFromStringMap.ShadingRatePaletteEntryNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CoarseSampleOrderTypeNV> from_string<CoarseSampleOrderTypeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CoarseSampleOrderTypeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.CoarseSampleOrderTypeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_ray_tracing ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMemoryRequirementsTypeNV>
|
|
from_string<AccelerationStructureMemoryRequirementsTypeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureMemoryRequirementsTypeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureMemoryRequirementsTypeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_pipeline_compiler_control ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCompilerControlFlagBitsAMD> from_string<PipelineCompilerControlFlagBitsAMD>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_calibrated_timestamps ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<TimeDomainEXT> from_string<TimeDomainEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.TimeDomainEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.TimeDomainEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_global_priority ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueueGlobalPriorityKHR> from_string<QueueGlobalPriorityKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueueGlobalPriorityKHREntries.find( value );
|
|
if ( it != enumFromStringMap.QueueGlobalPriorityKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_memory_overallocation_behavior ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MemoryOverallocationBehaviorAMD> from_string<MemoryOverallocationBehaviorAMD>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryOverallocationBehaviorAMDEntries.find( value );
|
|
if ( it != enumFromStringMap.MemoryOverallocationBehaviorAMDEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_INTEL_performance_query ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceConfigurationTypeINTEL> from_string<PerformanceConfigurationTypeINTEL>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceConfigurationTypeINTELEntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceConfigurationTypeINTELEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<QueryPoolSamplingModeINTEL> from_string<QueryPoolSamplingModeINTEL>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryPoolSamplingModeINTELEntries.find( value );
|
|
if ( it != enumFromStringMap.QueryPoolSamplingModeINTELEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceOverrideTypeINTEL> from_string<PerformanceOverrideTypeINTEL>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceOverrideTypeINTELEntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceOverrideTypeINTELEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceParameterTypeINTEL> from_string<PerformanceParameterTypeINTEL>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceParameterTypeINTELEntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceParameterTypeINTELEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PerformanceValueTypeINTEL> from_string<PerformanceValueTypeINTEL>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceValueTypeINTELEntries.find( value );
|
|
if ( it != enumFromStringMap.PerformanceValueTypeINTELEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImagePipeSurfaceCreateFlagBitsFUCHSIA> from_string<ImagePipeSurfaceCreateFlagBitsFUCHSIA>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
//=== VK_EXT_metal_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MetalSurfaceCreateFlagBitsEXT> from_string<MetalSurfaceCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
|
//=== VK_KHR_fragment_shading_rate ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FragmentShadingRateCombinerOpKHR> from_string<FragmentShadingRateCombinerOpKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FragmentShadingRateCombinerOpKHREntries.find( value );
|
|
if ( it != enumFromStringMap.FragmentShadingRateCombinerOpKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_shader_core_properties2 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderCorePropertiesFlagBitsAMD> from_string<ShaderCorePropertiesFlagBitsAMD>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_validation_features ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ValidationFeatureEnableEXT> from_string<ValidationFeatureEnableEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationFeatureEnableEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ValidationFeatureEnableEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ValidationFeatureDisableEXT> from_string<ValidationFeatureDisableEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationFeatureDisableEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ValidationFeatureDisableEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_coverage_reduction_mode ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CoverageReductionModeNV> from_string<CoverageReductionModeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CoverageReductionModeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.CoverageReductionModeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCoverageReductionStateCreateFlagBitsNV>
|
|
from_string<PipelineCoverageReductionStateCreateFlagBitsNV>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_provoking_vertex ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ProvokingVertexModeEXT> from_string<ProvokingVertexModeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ProvokingVertexModeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ProvokingVertexModeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_EXT_full_screen_exclusive ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FullScreenExclusiveEXT> from_string<FullScreenExclusiveEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FullScreenExclusiveEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.FullScreenExclusiveEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
//=== VK_EXT_headless_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<HeadlessSurfaceCreateFlagBitsEXT> from_string<HeadlessSurfaceCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_line_rasterization ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<LineRasterizationModeEXT> from_string<LineRasterizationModeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LineRasterizationModeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.LineRasterizationModeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_pipeline_executable_properties ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineExecutableStatisticFormatKHR> from_string<PipelineExecutableStatisticFormatKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineExecutableStatisticFormatKHREntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineExecutableStatisticFormatKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_host_image_copy ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<HostImageCopyFlagBitsEXT> from_string<HostImageCopyFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.HostImageCopyFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.HostImageCopyFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_map_memory2 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MemoryUnmapFlagBitsKHR> from_string<MemoryUnmapFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_surface_maintenance1 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PresentScalingFlagBitsEXT> from_string<PresentScalingFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PresentScalingFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.PresentScalingFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PresentGravityFlagBitsEXT> from_string<PresentGravityFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PresentGravityFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.PresentGravityFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_device_generated_commands ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<IndirectStateFlagBitsNV> from_string<IndirectStateFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndirectStateFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.IndirectStateFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<IndirectCommandsTokenTypeNV> from_string<IndirectCommandsTokenTypeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndirectCommandsTokenTypeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.IndirectCommandsTokenTypeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<IndirectCommandsLayoutUsageFlagBitsNV> from_string<IndirectCommandsLayoutUsageFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndirectCommandsLayoutUsageFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.IndirectCommandsLayoutUsageFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_depth_bias_control ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DepthBiasRepresentationEXT> from_string<DepthBiasRepresentationEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DepthBiasRepresentationEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DepthBiasRepresentationEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_device_memory_report ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceMemoryReportEventTypeEXT> from_string<DeviceMemoryReportEventTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceMemoryReportEventTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceMemoryReportEventTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceMemoryReportFlagBitsEXT> from_string<DeviceMemoryReportFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_KHR_video_encode_queue ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeCapabilityFlagBitsKHR> from_string<VideoEncodeCapabilityFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeCapabilityFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeCapabilityFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeFeedbackFlagBitsKHR> from_string<VideoEncodeFeedbackFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeFeedbackFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeFeedbackFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeUsageFlagBitsKHR> from_string<VideoEncodeUsageFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeUsageFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeUsageFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeContentFlagBitsKHR> from_string<VideoEncodeContentFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeContentFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeContentFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeTuningModeKHR> from_string<VideoEncodeTuningModeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeTuningModeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeTuningModeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeRateControlModeFlagBitsKHR> from_string<VideoEncodeRateControlModeFlagBitsKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeRateControlModeFlagBitsKHREntries.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeRateControlModeFlagBitsKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeFlagBitsKHR> from_string<VideoEncodeFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeRateControlFlagBitsKHR> from_string<VideoEncodeRateControlFlagBitsKHR>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_NV_device_diagnostics_config ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceDiagnosticsConfigFlagBitsNV> from_string<DeviceDiagnosticsConfigFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceDiagnosticsConfigFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceDiagnosticsConfigFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
//=== VK_EXT_metal_objects ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ExportMetalObjectTypeFlagBitsEXT> from_string<ExportMetalObjectTypeFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExportMetalObjectTypeFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ExportMetalObjectTypeFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
|
//=== VK_EXT_graphics_pipeline_library ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<GraphicsPipelineLibraryFlagBitsEXT> from_string<GraphicsPipelineLibraryFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GraphicsPipelineLibraryFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.GraphicsPipelineLibraryFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_fragment_shading_rate_enums ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FragmentShadingRateNV> from_string<FragmentShadingRateNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FragmentShadingRateNVEntries.find( value );
|
|
if ( it != enumFromStringMap.FragmentShadingRateNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FragmentShadingRateTypeNV> from_string<FragmentShadingRateTypeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FragmentShadingRateTypeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.FragmentShadingRateTypeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_ray_tracing_motion_blur ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMotionInstanceTypeNV> from_string<AccelerationStructureMotionInstanceTypeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureMotionInstanceTypeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureMotionInstanceTypeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMotionInfoFlagBitsNV> from_string<AccelerationStructureMotionInfoFlagBitsNV>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMotionInstanceFlagBitsNV>
|
|
from_string<AccelerationStructureMotionInstanceFlagBitsNV>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_image_compression_control ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageCompressionFlagBitsEXT> from_string<ImageCompressionFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageCompressionFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageCompressionFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageCompressionFixedRateFlagBitsEXT> from_string<ImageCompressionFixedRateFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageCompressionFixedRateFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageCompressionFixedRateFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_device_fault ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceFaultAddressTypeEXT> from_string<DeviceFaultAddressTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceFaultAddressTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceFaultAddressTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceFaultVendorBinaryHeaderVersionEXT> from_string<DeviceFaultVendorBinaryHeaderVersionEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceFaultVendorBinaryHeaderVersionEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceFaultVendorBinaryHeaderVersionEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
//=== VK_EXT_directfb_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DirectFBSurfaceCreateFlagBitsEXT> from_string<DirectFBSurfaceCreateFlagBitsEXT>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
|
//=== VK_EXT_device_address_binding_report ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceAddressBindingFlagBitsEXT> from_string<DeviceAddressBindingFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceAddressBindingFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceAddressBindingFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DeviceAddressBindingTypeEXT> from_string<DeviceAddressBindingTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceAddressBindingTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.DeviceAddressBindingTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_buffer_collection ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageConstraintsInfoFlagBitsFUCHSIA> from_string<ImageConstraintsInfoFlagBitsFUCHSIA>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageConstraintsInfoFlagBitsFUCHSIAEntries.find( value );
|
|
if ( it != enumFromStringMap.ImageConstraintsInfoFlagBitsFUCHSIAEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ImageFormatConstraintsFlagBitsFUCHSIA> from_string<ImageFormatConstraintsFlagBitsFUCHSIA>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
//=== VK_EXT_frame_boundary ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<FrameBoundaryFlagBitsEXT> from_string<FrameBoundaryFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FrameBoundaryFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.FrameBoundaryFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
//=== VK_QNX_screen_surface ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ScreenSurfaceCreateFlagBitsQNX> from_string<ScreenSurfaceCreateFlagBitsQNX>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
|
//=== VK_EXT_opacity_micromap ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MicromapTypeEXT> from_string<MicromapTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MicromapTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.MicromapTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BuildMicromapFlagBitsEXT> from_string<BuildMicromapFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildMicromapFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.BuildMicromapFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CopyMicromapModeEXT> from_string<CopyMicromapModeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CopyMicromapModeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.CopyMicromapModeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MicromapCreateFlagBitsEXT> from_string<MicromapCreateFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MicromapCreateFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.MicromapCreateFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BuildMicromapModeEXT> from_string<BuildMicromapModeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildMicromapModeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.BuildMicromapModeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpacityMicromapFormatEXT> from_string<OpacityMicromapFormatEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpacityMicromapFormatEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.OpacityMicromapFormatEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpacityMicromapSpecialIndexEXT> from_string<OpacityMicromapSpecialIndexEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpacityMicromapSpecialIndexEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.OpacityMicromapSpecialIndexEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_NV_displacement_micromap ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DisplacementMicromapFormatNV> from_string<DisplacementMicromapFormatNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplacementMicromapFormatNVEntries.find( value );
|
|
if ( it != enumFromStringMap.DisplacementMicromapFormatNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_ARM_scheduling_controls ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PhysicalDeviceSchedulingControlsFlagBitsARM>
|
|
from_string<PhysicalDeviceSchedulingControlsFlagBitsARM>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PhysicalDeviceSchedulingControlsFlagBitsARMEntries.find( value );
|
|
if ( it != enumFromStringMap.PhysicalDeviceSchedulingControlsFlagBitsARMEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_memory_decompression ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<MemoryDecompressionMethodFlagBitsNV> from_string<MemoryDecompressionMethodFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryDecompressionMethodFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.MemoryDecompressionMethodFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_subpass_merge_feedback ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<SubpassMergeStatusEXT> from_string<SubpassMergeStatusEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubpassMergeStatusEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.SubpassMergeStatusEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_LUNARG_direct_driver_loading ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DirectDriverLoadingModeLUNARG> from_string<DirectDriverLoadingModeLUNARG>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DirectDriverLoadingModeLUNARGEntries.find( value );
|
|
if ( it != enumFromStringMap.DirectDriverLoadingModeLUNARGEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<DirectDriverLoadingFlagBitsLUNARG> from_string<DirectDriverLoadingFlagBitsLUNARG>( const std::string & )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_optical_flow ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowUsageFlagBitsNV> from_string<OpticalFlowUsageFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowUsageFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowUsageFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowGridSizeFlagBitsNV> from_string<OpticalFlowGridSizeFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowGridSizeFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowGridSizeFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowPerformanceLevelNV> from_string<OpticalFlowPerformanceLevelNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowPerformanceLevelNVEntries.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowPerformanceLevelNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowSessionBindingPointNV> from_string<OpticalFlowSessionBindingPointNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowSessionBindingPointNVEntries.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowSessionBindingPointNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowSessionCreateFlagBitsNV> from_string<OpticalFlowSessionCreateFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowSessionCreateFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowSessionCreateFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowExecuteFlagBitsNV> from_string<OpticalFlowExecuteFlagBitsNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowExecuteFlagBitsNVEntries.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowExecuteFlagBitsNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_maintenance5 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<PipelineCreateFlagBits2KHR> from_string<PipelineCreateFlagBits2KHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCreateFlagBits2KHREntries.find( value );
|
|
if ( it != enumFromStringMap.PipelineCreateFlagBits2KHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BufferUsageFlagBits2KHR> from_string<BufferUsageFlagBits2KHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BufferUsageFlagBits2KHREntries.find( value );
|
|
if ( it != enumFromStringMap.BufferUsageFlagBits2KHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_shader_object ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderCreateFlagBitsEXT> from_string<ShaderCreateFlagBitsEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderCreateFlagBitsEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ShaderCreateFlagBitsEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ShaderCodeTypeEXT> from_string<ShaderCodeTypeEXT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderCodeTypeEXTEntries.find( value );
|
|
if ( it != enumFromStringMap.ShaderCodeTypeEXTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_ray_tracing_invocation_reorder ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<RayTracingInvocationReorderModeNV> from_string<RayTracingInvocationReorderModeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RayTracingInvocationReorderModeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.RayTracingInvocationReorderModeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_low_latency2 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<LatencyMarkerNV> from_string<LatencyMarkerNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LatencyMarkerNVEntries.find( value );
|
|
if ( it != enumFromStringMap.LatencyMarkerNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<OutOfBandQueueTypeNV> from_string<OutOfBandQueueTypeNV>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OutOfBandQueueTypeNVEntries.find( value );
|
|
if ( it != enumFromStringMap.OutOfBandQueueTypeNVEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_cooperative_matrix ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ScopeKHR> from_string<ScopeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ScopeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.ScopeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<ComponentTypeKHR> from_string<ComponentTypeKHR>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ComponentTypeKHREntries.find( value );
|
|
if ( it != enumFromStringMap.ComponentTypeKHREntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_QCOM_image_processing2 ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<BlockMatchWindowCompareModeQCOM> from_string<BlockMatchWindowCompareModeQCOM>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlockMatchWindowCompareModeQCOMEntries.find( value );
|
|
if ( it != enumFromStringMap.BlockMatchWindowCompareModeQCOMEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_QCOM_filter_cubic_weights ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<CubicFilterWeightsQCOM> from_string<CubicFilterWeightsQCOM>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CubicFilterWeightsQCOMEntries.find( value );
|
|
if ( it != enumFromStringMap.CubicFilterWeightsQCOMEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_MSFT_layered_driver ===
|
|
|
|
template <>
|
|
VULKAN_HPP_INLINE std::optional<LayeredDriverUnderlyingApiMSFT> from_string<LayeredDriverUnderlyingApiMSFT>( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LayeredDriverUnderlyingApiMSFTEntries.find( value );
|
|
if ( it != enumFromStringMap.LayeredDriverUnderlyingApiMSFTEntries.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
} // namespace VULKAN_HPP_NAMESPACE
|
|
#endif
|