7461 lines
356 KiB
C++
7461 lines
356 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 ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
|
|
}
|
|
|
|
//=========================
|
|
//=== ENUMs from_string ===
|
|
//=========================
|
|
|
|
struct EnumFromStringMap
|
|
{
|
|
//=== VK_VERSION_1_0 ===
|
|
|
|
std::unordered_map<std::string, Result> Result = {
|
|
{ "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> StructureType = {
|
|
{ "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> PipelineCacheHeaderVersion = {
|
|
{ "One", PipelineCacheHeaderVersion::eOne },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ObjectType> ObjectType = {
|
|
{ "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> VendorId = {
|
|
{ "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> Format = {
|
|
{ "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> FormatFeatureFlagBits = {
|
|
{ "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> ImageCreateFlagBits = {
|
|
{ "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> ImageTiling = {
|
|
{ "Optimal", ImageTiling::eOptimal },
|
|
{ "Linear", ImageTiling::eLinear },
|
|
{ "DrmFormatModifierEXT", ImageTiling::eDrmFormatModifierEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageType> ImageType = {
|
|
{ "1D", ImageType::e1D },
|
|
{ "2D", ImageType::e2D },
|
|
{ "3D", ImageType::e3D },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageUsageFlagBits> ImageUsageFlagBits = {
|
|
{ "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> InstanceCreateFlagBits = {
|
|
{ "EnumeratePortabilityKHR", InstanceCreateFlagBits::eEnumeratePortabilityKHR },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, InternalAllocationType> InternalAllocationType = {
|
|
{ "Executable", InternalAllocationType::eExecutable },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MemoryHeapFlagBits> MemoryHeapFlagBits = {
|
|
{ "DeviceLocal", MemoryHeapFlagBits::eDeviceLocal },
|
|
{ "MultiInstance", MemoryHeapFlagBits::eMultiInstance },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MemoryPropertyFlagBits> MemoryPropertyFlagBits = {
|
|
{ "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> PhysicalDeviceType = {
|
|
{ "Other", PhysicalDeviceType::eOther },
|
|
{ "IntegratedGpu", PhysicalDeviceType::eIntegratedGpu },
|
|
{ "DiscreteGpu", PhysicalDeviceType::eDiscreteGpu },
|
|
{ "VirtualGpu", PhysicalDeviceType::eVirtualGpu },
|
|
{ "Cpu", PhysicalDeviceType::eCpu },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueueFlagBits> QueueFlagBits = {
|
|
{ "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> SampleCountFlagBits = {
|
|
{ "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> SystemAllocationScope = {
|
|
{ "Command", SystemAllocationScope::eCommand }, { "Object", SystemAllocationScope::eObject }, { "Cache", SystemAllocationScope::eCache },
|
|
{ "Device", SystemAllocationScope::eDevice }, { "Instance", SystemAllocationScope::eInstance },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceCreateFlagBits> DeviceCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceQueueCreateFlagBits> DeviceQueueCreateFlagBits = {
|
|
{ "Protected", DeviceQueueCreateFlagBits::eProtected },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineStageFlagBits> PipelineStageFlagBits = {
|
|
{ "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> MemoryMapFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageAspectFlagBits> ImageAspectFlagBits = {
|
|
{ "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> SparseImageFormatFlagBits = {
|
|
{ "SingleMiptail", SparseImageFormatFlagBits::eSingleMiptail },
|
|
{ "AlignedMipSize", SparseImageFormatFlagBits::eAlignedMipSize },
|
|
{ "NonstandardBlockSize", SparseImageFormatFlagBits::eNonstandardBlockSize },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SparseMemoryBindFlagBits> SparseMemoryBindFlagBits = {
|
|
{ "Metadata", SparseMemoryBindFlagBits::eMetadata },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FenceCreateFlagBits> FenceCreateFlagBits = {
|
|
{ "Signaled", FenceCreateFlagBits::eSignaled },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreCreateFlagBits> SemaphoreCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, EventCreateFlagBits> EventCreateFlagBits = {
|
|
{ "DeviceOnly", EventCreateFlagBits::eDeviceOnly },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryPipelineStatisticFlagBits> QueryPipelineStatisticFlagBits = {
|
|
{ "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> QueryResultFlagBits = {
|
|
{ "64", QueryResultFlagBits::e64 },
|
|
{ "Wait", QueryResultFlagBits::eWait },
|
|
{ "WithAvailability", QueryResultFlagBits::eWithAvailability },
|
|
{ "Partial", QueryResultFlagBits::ePartial },
|
|
{ "WithStatusKHR", QueryResultFlagBits::eWithStatusKHR },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryType> QueryType = {
|
|
{ "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> QueryPoolCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BufferCreateFlagBits> BufferCreateFlagBits = {
|
|
{ "SparseBinding", BufferCreateFlagBits::eSparseBinding },
|
|
{ "SparseResidency", BufferCreateFlagBits::eSparseResidency },
|
|
{ "SparseAliased", BufferCreateFlagBits::eSparseAliased },
|
|
{ "Protected", BufferCreateFlagBits::eProtected },
|
|
{ "DeviceAddressCaptureReplay", BufferCreateFlagBits::eDeviceAddressCaptureReplay },
|
|
{ "DescriptorBufferCaptureReplayEXT", BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BufferUsageFlagBits> BufferUsageFlagBits = {
|
|
{ "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> SharingMode = {
|
|
{ "Exclusive", SharingMode::eExclusive },
|
|
{ "Concurrent", SharingMode::eConcurrent },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BufferViewCreateFlagBits> BufferViewCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageLayout> ImageLayout = {
|
|
{ "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> ComponentSwizzle = {
|
|
{ "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> ImageViewCreateFlagBits = {
|
|
{ "FragmentDensityMapDynamicEXT", ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT },
|
|
{ "DescriptorBufferCaptureReplayEXT", ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT },
|
|
{ "FragmentDensityMapDeferredEXT", ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageViewType> ImageViewType = {
|
|
{ "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> ShaderModuleCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCacheCreateFlagBits> PipelineCacheCreateFlagBits = {
|
|
{ "ExternallySynchronized", PipelineCacheCreateFlagBits::eExternallySynchronized },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BlendFactor> BlendFactor = {
|
|
{ "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> BlendOp = {
|
|
{ "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> ColorComponentFlagBits = {
|
|
{ "R", ColorComponentFlagBits::eR },
|
|
{ "G", ColorComponentFlagBits::eG },
|
|
{ "B", ColorComponentFlagBits::eB },
|
|
{ "A", ColorComponentFlagBits::eA },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CompareOp> CompareOp = {
|
|
{ "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> CullModeFlagBits = {
|
|
{ "None", CullModeFlagBits::eNone },
|
|
{ "Front", CullModeFlagBits::eFront },
|
|
{ "Back", CullModeFlagBits::eBack },
|
|
{ "FrontAndBack", CullModeFlagBits::eFrontAndBack },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DynamicState> DynamicState = {
|
|
{ "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> FrontFace = {
|
|
{ "CounterClockwise", FrontFace::eCounterClockwise },
|
|
{ "Clockwise", FrontFace::eClockwise },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, LogicOp> LogicOp = {
|
|
{ "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> PipelineCreateFlagBits = {
|
|
{ "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> PipelineShaderStageCreateFlagBits = {
|
|
{ "AllowVaryingSubgroupSize", PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize },
|
|
{ "RequireFullSubgroups", PipelineShaderStageCreateFlagBits::eRequireFullSubgroups },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PolygonMode> PolygonMode = {
|
|
{ "Fill", PolygonMode::eFill },
|
|
{ "Line", PolygonMode::eLine },
|
|
{ "Point", PolygonMode::ePoint },
|
|
{ "FillRectangleNV", PolygonMode::eFillRectangleNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PrimitiveTopology> PrimitiveTopology = {
|
|
{ "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> ShaderStageFlagBits = {
|
|
{ "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> StencilOp = {
|
|
{ "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> VertexInputRate = {
|
|
{ "Vertex", VertexInputRate::eVertex },
|
|
{ "Instance", VertexInputRate::eInstance },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineColorBlendStateCreateFlagBits> PipelineColorBlendStateCreateFlagBits = {
|
|
{ "RasterizationOrderAttachmentAccessEXT", PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineDepthStencilStateCreateFlagBits> PipelineDepthStencilStateCreateFlagBits = {
|
|
{ "RasterizationOrderAttachmentDepthAccessEXT", PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT },
|
|
{ "RasterizationOrderAttachmentStencilAccessEXT", PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineDynamicStateCreateFlagBits> PipelineDynamicStateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineInputAssemblyStateCreateFlagBits> PipelineInputAssemblyStateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineLayoutCreateFlagBits> PipelineLayoutCreateFlagBits = {
|
|
{ "IndependentSetsEXT", PipelineLayoutCreateFlagBits::eIndependentSetsEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineMultisampleStateCreateFlagBits> PipelineMultisampleStateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationStateCreateFlagBits> PipelineRasterizationStateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineTessellationStateCreateFlagBits> PipelineTessellationStateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineVertexInputStateCreateFlagBits> PipelineVertexInputStateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineViewportStateCreateFlagBits> PipelineViewportStateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BorderColor> BorderColor = {
|
|
{ "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> Filter = {
|
|
{ "Nearest", Filter::eNearest },
|
|
{ "Linear", Filter::eLinear },
|
|
{ "CubicEXT", Filter::eCubicEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerAddressMode> SamplerAddressMode = {
|
|
{ "Repeat", SamplerAddressMode::eRepeat },
|
|
{ "MirroredRepeat", SamplerAddressMode::eMirroredRepeat },
|
|
{ "ClampToEdge", SamplerAddressMode::eClampToEdge },
|
|
{ "ClampToBorder", SamplerAddressMode::eClampToBorder },
|
|
{ "MirrorClampToEdge", SamplerAddressMode::eMirrorClampToEdge },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerCreateFlagBits> SamplerCreateFlagBits = {
|
|
{ "SubsampledEXT", SamplerCreateFlagBits::eSubsampledEXT },
|
|
{ "SubsampledCoarseReconstructionEXT", SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT },
|
|
{ "DescriptorBufferCaptureReplayEXT", SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT },
|
|
{ "NonSeamlessCubeMapEXT", SamplerCreateFlagBits::eNonSeamlessCubeMapEXT },
|
|
{ "ImageProcessingQCOM", SamplerCreateFlagBits::eImageProcessingQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerMipmapMode> SamplerMipmapMode = {
|
|
{ "Nearest", SamplerMipmapMode::eNearest },
|
|
{ "Linear", SamplerMipmapMode::eLinear },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorPoolCreateFlagBits> DescriptorPoolCreateFlagBits = {
|
|
{ "FreeDescriptorSet", DescriptorPoolCreateFlagBits::eFreeDescriptorSet },
|
|
{ "UpdateAfterBind", DescriptorPoolCreateFlagBits::eUpdateAfterBind },
|
|
{ "HostOnlyEXT", DescriptorPoolCreateFlagBits::eHostOnlyEXT },
|
|
{ "AllowOverallocationSetsNV", DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV },
|
|
{ "AllowOverallocationPoolsNV", DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorSetLayoutCreateFlagBits> DescriptorSetLayoutCreateFlagBits = {
|
|
{ "UpdateAfterBindPool", DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool },
|
|
{ "PushDescriptorKHR", DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR },
|
|
{ "DescriptorBufferEXT", DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT },
|
|
{ "EmbeddedImmutableSamplersEXT", DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT },
|
|
{ "IndirectBindableNV", DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV },
|
|
{ "HostOnlyPoolEXT", DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorType> DescriptorType = {
|
|
{ "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> DescriptorPoolResetFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccessFlagBits> AccessFlagBits = {
|
|
{ "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> AttachmentDescriptionFlagBits = {
|
|
{ "MayAlias", AttachmentDescriptionFlagBits::eMayAlias },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AttachmentLoadOp> AttachmentLoadOp = {
|
|
{ "Load", AttachmentLoadOp::eLoad },
|
|
{ "Clear", AttachmentLoadOp::eClear },
|
|
{ "DontCare", AttachmentLoadOp::eDontCare },
|
|
{ "NoneEXT", AttachmentLoadOp::eNoneEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AttachmentStoreOp> AttachmentStoreOp = {
|
|
{ "Store", AttachmentStoreOp::eStore },
|
|
{ "DontCare", AttachmentStoreOp::eDontCare },
|
|
{ "None", AttachmentStoreOp::eNone },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DependencyFlagBits> DependencyFlagBits = {
|
|
{ "ByRegion", DependencyFlagBits::eByRegion },
|
|
{ "DeviceGroup", DependencyFlagBits::eDeviceGroup },
|
|
{ "ViewLocal", DependencyFlagBits::eViewLocal },
|
|
{ "FeedbackLoopEXT", DependencyFlagBits::eFeedbackLoopEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FramebufferCreateFlagBits> FramebufferCreateFlagBits = {
|
|
{ "Imageless", FramebufferCreateFlagBits::eImageless },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineBindPoint> PipelineBindPoint = {
|
|
{ "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> RenderPassCreateFlagBits = {
|
|
{ "TransformQCOM", RenderPassCreateFlagBits::eTransformQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SubpassDescriptionFlagBits> SubpassDescriptionFlagBits = {
|
|
{ "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> CommandPoolCreateFlagBits = {
|
|
{ "Transient", CommandPoolCreateFlagBits::eTransient },
|
|
{ "ResetCommandBuffer", CommandPoolCreateFlagBits::eResetCommandBuffer },
|
|
{ "Protected", CommandPoolCreateFlagBits::eProtected },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandPoolResetFlagBits> CommandPoolResetFlagBits = {
|
|
{ "ReleaseResources", CommandPoolResetFlagBits::eReleaseResources },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandBufferLevel> CommandBufferLevel = {
|
|
{ "Primary", CommandBufferLevel::ePrimary },
|
|
{ "Secondary", CommandBufferLevel::eSecondary },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandBufferResetFlagBits> CommandBufferResetFlagBits = {
|
|
{ "ReleaseResources", CommandBufferResetFlagBits::eReleaseResources },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandBufferUsageFlagBits> CommandBufferUsageFlagBits = {
|
|
{ "OneTimeSubmit", CommandBufferUsageFlagBits::eOneTimeSubmit },
|
|
{ "RenderPassContinue", CommandBufferUsageFlagBits::eRenderPassContinue },
|
|
{ "SimultaneousUse", CommandBufferUsageFlagBits::eSimultaneousUse },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryControlFlagBits> QueryControlFlagBits = {
|
|
{ "Precise", QueryControlFlagBits::ePrecise },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, IndexType> IndexType = {
|
|
{ "Uint16", IndexType::eUint16 },
|
|
{ "Uint32", IndexType::eUint32 },
|
|
{ "NoneKHR", IndexType::eNoneKHR },
|
|
{ "Uint8EXT", IndexType::eUint8EXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, StencilFaceFlagBits> StencilFaceFlagBits = {
|
|
{ "Front", StencilFaceFlagBits::eFront },
|
|
{ "Back", StencilFaceFlagBits::eBack },
|
|
{ "FrontAndBack", StencilFaceFlagBits::eFrontAndBack },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SubpassContents> SubpassContents = {
|
|
{ "Inline", SubpassContents::eInline },
|
|
{ "SecondaryCommandBuffers", SubpassContents::eSecondaryCommandBuffers },
|
|
{ "InlineAndSecondaryCommandBuffersEXT", SubpassContents::eInlineAndSecondaryCommandBuffersEXT },
|
|
|
|
};
|
|
|
|
//=== VK_VERSION_1_1 ===
|
|
|
|
std::unordered_map<std::string, SubgroupFeatureFlagBits> SubgroupFeatureFlagBits = {
|
|
{ "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> PeerMemoryFeatureFlagBits = {
|
|
{ "CopySrc", PeerMemoryFeatureFlagBits::eCopySrc },
|
|
{ "CopyDst", PeerMemoryFeatureFlagBits::eCopyDst },
|
|
{ "GenericSrc", PeerMemoryFeatureFlagBits::eGenericSrc },
|
|
{ "GenericDst", PeerMemoryFeatureFlagBits::eGenericDst },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MemoryAllocateFlagBits> MemoryAllocateFlagBits = {
|
|
{ "DeviceMask", MemoryAllocateFlagBits::eDeviceMask },
|
|
{ "DeviceAddress", MemoryAllocateFlagBits::eDeviceAddress },
|
|
{ "DeviceAddressCaptureReplay", MemoryAllocateFlagBits::eDeviceAddressCaptureReplay },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CommandPoolTrimFlagBits> CommandPoolTrimFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PointClippingBehavior> PointClippingBehavior = {
|
|
{ "AllClipPlanes", PointClippingBehavior::eAllClipPlanes },
|
|
{ "UserClipPlanesOnly", PointClippingBehavior::eUserClipPlanesOnly },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, TessellationDomainOrigin> TessellationDomainOrigin = {
|
|
{ "UpperLeft", TessellationDomainOrigin::eUpperLeft },
|
|
{ "LowerLeft", TessellationDomainOrigin::eLowerLeft },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerYcbcrModelConversion> SamplerYcbcrModelConversion = {
|
|
{ "RgbIdentity", SamplerYcbcrModelConversion::eRgbIdentity }, { "YcbcrIdentity", SamplerYcbcrModelConversion::eYcbcrIdentity },
|
|
{ "Ycbcr709", SamplerYcbcrModelConversion::eYcbcr709 }, { "Ycbcr601", SamplerYcbcrModelConversion::eYcbcr601 },
|
|
{ "Ycbcr2020", SamplerYcbcrModelConversion::eYcbcr2020 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SamplerYcbcrRange> SamplerYcbcrRange = {
|
|
{ "ItuFull", SamplerYcbcrRange::eItuFull },
|
|
{ "ItuNarrow", SamplerYcbcrRange::eItuNarrow },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ChromaLocation> ChromaLocation = {
|
|
{ "CositedEven", ChromaLocation::eCositedEven },
|
|
{ "Midpoint", ChromaLocation::eMidpoint },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorUpdateTemplateType> DescriptorUpdateTemplateType = {
|
|
{ "DescriptorSet", DescriptorUpdateTemplateType::eDescriptorSet },
|
|
{ "PushDescriptorsKHR", DescriptorUpdateTemplateType::ePushDescriptorsKHR },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorUpdateTemplateCreateFlagBits> DescriptorUpdateTemplateCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalMemoryHandleTypeFlagBits> ExternalMemoryHandleTypeFlagBits = {
|
|
{ "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> ExternalMemoryFeatureFlagBits = {
|
|
{ "DedicatedOnly", ExternalMemoryFeatureFlagBits::eDedicatedOnly },
|
|
{ "Exportable", ExternalMemoryFeatureFlagBits::eExportable },
|
|
{ "Importable", ExternalMemoryFeatureFlagBits::eImportable },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalFenceHandleTypeFlagBits> ExternalFenceHandleTypeFlagBits = {
|
|
{ "OpaqueFd", ExternalFenceHandleTypeFlagBits::eOpaqueFd },
|
|
{ "OpaqueWin32", ExternalFenceHandleTypeFlagBits::eOpaqueWin32 },
|
|
{ "OpaqueWin32Kmt", ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt },
|
|
{ "SyncFd", ExternalFenceHandleTypeFlagBits::eSyncFd },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalFenceFeatureFlagBits> ExternalFenceFeatureFlagBits = {
|
|
{ "Exportable", ExternalFenceFeatureFlagBits::eExportable },
|
|
{ "Importable", ExternalFenceFeatureFlagBits::eImportable },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FenceImportFlagBits> FenceImportFlagBits = {
|
|
{ "Temporary", FenceImportFlagBits::eTemporary },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreImportFlagBits> SemaphoreImportFlagBits = {
|
|
{ "Temporary", SemaphoreImportFlagBits::eTemporary },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalSemaphoreHandleTypeFlagBits> ExternalSemaphoreHandleTypeFlagBits = {
|
|
{ "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> ExternalSemaphoreFeatureFlagBits = {
|
|
{ "Exportable", ExternalSemaphoreFeatureFlagBits::eExportable },
|
|
{ "Importable", ExternalSemaphoreFeatureFlagBits::eImportable },
|
|
|
|
};
|
|
|
|
//=== VK_VERSION_1_2 ===
|
|
|
|
std::unordered_map<std::string, DriverId> DriverId = {
|
|
{ "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> ShaderFloatControlsIndependence = {
|
|
{ "32BitOnly", ShaderFloatControlsIndependence::e32BitOnly },
|
|
{ "All", ShaderFloatControlsIndependence::eAll },
|
|
{ "None", ShaderFloatControlsIndependence::eNone },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DescriptorBindingFlagBits> DescriptorBindingFlagBits = {
|
|
{ "UpdateAfterBind", DescriptorBindingFlagBits::eUpdateAfterBind },
|
|
{ "UpdateUnusedWhilePending", DescriptorBindingFlagBits::eUpdateUnusedWhilePending },
|
|
{ "PartiallyBound", DescriptorBindingFlagBits::ePartiallyBound },
|
|
{ "VariableDescriptorCount", DescriptorBindingFlagBits::eVariableDescriptorCount },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ResolveModeFlagBits> ResolveModeFlagBits = {
|
|
{ "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> SamplerReductionMode = {
|
|
{ "WeightedAverage", SamplerReductionMode::eWeightedAverage },
|
|
{ "Min", SamplerReductionMode::eMin },
|
|
{ "Max", SamplerReductionMode::eMax },
|
|
{ "WeightedAverageRangeclampQCOM", SamplerReductionMode::eWeightedAverageRangeclampQCOM },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreType> SemaphoreType = {
|
|
{ "Binary", SemaphoreType::eBinary },
|
|
{ "Timeline", SemaphoreType::eTimeline },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, SemaphoreWaitFlagBits> SemaphoreWaitFlagBits = {
|
|
{ "Any", SemaphoreWaitFlagBits::eAny },
|
|
|
|
};
|
|
|
|
//=== VK_VERSION_1_3 ===
|
|
|
|
std::unordered_map<std::string, PipelineCreationFeedbackFlagBits> PipelineCreationFeedbackFlagBits = {
|
|
{ "Valid", PipelineCreationFeedbackFlagBits::eValid },
|
|
{ "ApplicationPipelineCacheHit", PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit },
|
|
{ "BasePipelineAcceleration", PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ToolPurposeFlagBits> ToolPurposeFlagBits = {
|
|
{ "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> PrivateDataSlotCreateFlagBits = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineStageFlagBits2> PipelineStageFlagBits2 = {
|
|
{ "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> AccessFlagBits2 = {
|
|
{ "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> SubmitFlagBits = {
|
|
{ "Protected", SubmitFlagBits::eProtected },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, RenderingFlagBits> RenderingFlagBits = {
|
|
{ "ContentsSecondaryCommandBuffers", RenderingFlagBits::eContentsSecondaryCommandBuffers },
|
|
{ "Suspending", RenderingFlagBits::eSuspending },
|
|
{ "Resuming", RenderingFlagBits::eResuming },
|
|
{ "ContentsInlineEXT", RenderingFlagBits::eContentsInlineEXT },
|
|
{ "EnableLegacyDitheringEXT", RenderingFlagBits::eEnableLegacyDitheringEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, FormatFeatureFlagBits2> FormatFeatureFlagBits2 = {
|
|
{ "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> SurfaceTransformFlagBitsKHR = {
|
|
{ "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> PresentModeKHR = {
|
|
{ "Immediate", PresentModeKHR::eImmediate },
|
|
{ "Mailbox", PresentModeKHR::eMailbox },
|
|
{ "Fifo", PresentModeKHR::eFifo },
|
|
{ "FifoRelaxed", PresentModeKHR::eFifoRelaxed },
|
|
{ "SharedDemandRefresh", PresentModeKHR::eSharedDemandRefresh },
|
|
{ "SharedContinuousRefresh", PresentModeKHR::eSharedContinuousRefresh },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ColorSpaceKHR> ColorSpaceKHR = {
|
|
{ "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> CompositeAlphaFlagBitsKHR = {
|
|
{ "Opaque", CompositeAlphaFlagBitsKHR::eOpaque },
|
|
{ "PreMultiplied", CompositeAlphaFlagBitsKHR::ePreMultiplied },
|
|
{ "PostMultiplied", CompositeAlphaFlagBitsKHR::ePostMultiplied },
|
|
{ "Inherit", CompositeAlphaFlagBitsKHR::eInherit },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_swapchain ===
|
|
|
|
std::unordered_map<std::string, SwapchainCreateFlagBitsKHR> SwapchainCreateFlagBitsKHR = {
|
|
{ "SplitInstanceBindRegions", SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions },
|
|
{ "Protected", SwapchainCreateFlagBitsKHR::eProtected },
|
|
{ "MutableFormat", SwapchainCreateFlagBitsKHR::eMutableFormat },
|
|
{ "DeferredMemoryAllocationEXT", SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocationEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceGroupPresentModeFlagBitsKHR> DeviceGroupPresentModeFlagBitsKHR = {
|
|
{ "Local", DeviceGroupPresentModeFlagBitsKHR::eLocal },
|
|
{ "Remote", DeviceGroupPresentModeFlagBitsKHR::eRemote },
|
|
{ "Sum", DeviceGroupPresentModeFlagBitsKHR::eSum },
|
|
{ "LocalMultiDevice", DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_display ===
|
|
|
|
std::unordered_map<std::string, DisplayPlaneAlphaFlagBitsKHR> DisplayPlaneAlphaFlagBitsKHR = {
|
|
{ "Opaque", DisplayPlaneAlphaFlagBitsKHR::eOpaque },
|
|
{ "Global", DisplayPlaneAlphaFlagBitsKHR::eGlobal },
|
|
{ "PerPixel", DisplayPlaneAlphaFlagBitsKHR::ePerPixel },
|
|
{ "PerPixelPremultiplied", DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DisplayModeCreateFlagBitsKHR> DisplayModeCreateFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DisplaySurfaceCreateFlagBitsKHR> DisplaySurfaceCreateFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
//=== VK_KHR_xlib_surface ===
|
|
|
|
std::unordered_map<std::string, XlibSurfaceCreateFlagBitsKHR> XlibSurfaceCreateFlagBitsKHR = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
//=== VK_KHR_xcb_surface ===
|
|
|
|
std::unordered_map<std::string, XcbSurfaceCreateFlagBitsKHR> XcbSurfaceCreateFlagBitsKHR = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
//=== VK_KHR_wayland_surface ===
|
|
|
|
std::unordered_map<std::string, WaylandSurfaceCreateFlagBitsKHR> WaylandSurfaceCreateFlagBitsKHR = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
//=== VK_KHR_android_surface ===
|
|
|
|
std::unordered_map<std::string, AndroidSurfaceCreateFlagBitsKHR> AndroidSurfaceCreateFlagBitsKHR = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_KHR_win32_surface ===
|
|
|
|
std::unordered_map<std::string, Win32SurfaceCreateFlagBitsKHR> Win32SurfaceCreateFlagBitsKHR = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
//=== VK_EXT_debug_report ===
|
|
|
|
std::unordered_map<std::string, DebugReportFlagBitsEXT> DebugReportFlagBitsEXT = {
|
|
{ "Information", DebugReportFlagBitsEXT::eInformation },
|
|
{ "Warning", DebugReportFlagBitsEXT::eWarning },
|
|
{ "PerformanceWarning", DebugReportFlagBitsEXT::ePerformanceWarning },
|
|
{ "Error", DebugReportFlagBitsEXT::eError },
|
|
{ "Debug", DebugReportFlagBitsEXT::eDebug },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugReportObjectTypeEXT> DebugReportObjectTypeEXT = {
|
|
{ "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> RasterizationOrderAMD = {
|
|
{ "Strict", RasterizationOrderAMD::eStrict },
|
|
{ "Relaxed", RasterizationOrderAMD::eRelaxed },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_video_queue ===
|
|
|
|
std::unordered_map<std::string, VideoCodecOperationFlagBitsKHR> VideoCodecOperationFlagBitsKHR = {
|
|
{ "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> VideoChromaSubsamplingFlagBitsKHR = {
|
|
{ "Invalid", VideoChromaSubsamplingFlagBitsKHR::eInvalid }, { "Monochrome", VideoChromaSubsamplingFlagBitsKHR::eMonochrome },
|
|
{ "420", VideoChromaSubsamplingFlagBitsKHR::e420 }, { "422", VideoChromaSubsamplingFlagBitsKHR::e422 },
|
|
{ "444", VideoChromaSubsamplingFlagBitsKHR::e444 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoComponentBitDepthFlagBitsKHR> VideoComponentBitDepthFlagBitsKHR = {
|
|
{ "Invalid", VideoComponentBitDepthFlagBitsKHR::eInvalid },
|
|
{ "8", VideoComponentBitDepthFlagBitsKHR::e8 },
|
|
{ "10", VideoComponentBitDepthFlagBitsKHR::e10 },
|
|
{ "12", VideoComponentBitDepthFlagBitsKHR::e12 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoCapabilityFlagBitsKHR> VideoCapabilityFlagBitsKHR = {
|
|
{ "ProtectedContent", VideoCapabilityFlagBitsKHR::eProtectedContent },
|
|
{ "SeparateReferenceImages", VideoCapabilityFlagBitsKHR::eSeparateReferenceImages },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoSessionCreateFlagBitsKHR> VideoSessionCreateFlagBitsKHR = {
|
|
{ "ProtectedContent", VideoSessionCreateFlagBitsKHR::eProtectedContent },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "AllowEncodeParameterOptimizations", VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoCodingControlFlagBitsKHR> VideoCodingControlFlagBitsKHR = {
|
|
{ "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> QueryResultStatusKHR = {
|
|
{ "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> VideoSessionParametersCreateFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoBeginCodingFlagBitsKHR> VideoBeginCodingFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEndCodingFlagBitsKHR> VideoEndCodingFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
//=== VK_KHR_video_decode_queue ===
|
|
|
|
std::unordered_map<std::string, VideoDecodeCapabilityFlagBitsKHR> VideoDecodeCapabilityFlagBitsKHR = {
|
|
{ "DpbAndOutputCoincide", VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide },
|
|
{ "DpbAndOutputDistinct", VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoDecodeUsageFlagBitsKHR> VideoDecodeUsageFlagBitsKHR = {
|
|
{ "Default", VideoDecodeUsageFlagBitsKHR::eDefault },
|
|
{ "Transcoding", VideoDecodeUsageFlagBitsKHR::eTranscoding },
|
|
{ "Offline", VideoDecodeUsageFlagBitsKHR::eOffline },
|
|
{ "Streaming", VideoDecodeUsageFlagBitsKHR::eStreaming },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoDecodeFlagBitsKHR> VideoDecodeFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_transform_feedback ===
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationStateStreamCreateFlagBitsEXT> PipelineRasterizationStateStreamCreateFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_EXT_video_encode_h264 ===
|
|
|
|
std::unordered_map<std::string, VideoEncodeH264CapabilityFlagBitsEXT> VideoEncodeH264CapabilityFlagBitsEXT = {
|
|
{ "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> VideoEncodeH264StdFlagBitsEXT = {
|
|
{ "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> VideoEncodeH264RateControlFlagBitsEXT = {
|
|
{ "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> VideoEncodeH265CapabilityFlagBitsEXT = {
|
|
{ "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> VideoEncodeH265StdFlagBitsEXT = {
|
|
{ "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> VideoEncodeH265CtbSizeFlagBitsEXT = {
|
|
{ "16", VideoEncodeH265CtbSizeFlagBitsEXT::e16 },
|
|
{ "32", VideoEncodeH265CtbSizeFlagBitsEXT::e32 },
|
|
{ "64", VideoEncodeH265CtbSizeFlagBitsEXT::e64 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH265TransformBlockSizeFlagBitsEXT> VideoEncodeH265TransformBlockSizeFlagBitsEXT = {
|
|
{ "4", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e4 },
|
|
{ "8", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e8 },
|
|
{ "16", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e16 },
|
|
{ "32", VideoEncodeH265TransformBlockSizeFlagBitsEXT::e32 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeH265RateControlFlagBitsEXT> VideoEncodeH265RateControlFlagBitsEXT = {
|
|
{ "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> VideoDecodeH264PictureLayoutFlagBitsKHR = {
|
|
{ "Progressive", VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive },
|
|
{ "InterlacedInterleavedLines", VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines },
|
|
{ "InterlacedSeparatePlanes", VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes },
|
|
|
|
};
|
|
|
|
//=== VK_AMD_shader_info ===
|
|
|
|
std::unordered_map<std::string, ShaderInfoTypeAMD> ShaderInfoTypeAMD = {
|
|
{ "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> StreamDescriptorSurfaceCreateFlagBitsGGP = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_GGP*/
|
|
|
|
//=== VK_NV_external_memory_capabilities ===
|
|
|
|
std::unordered_map<std::string, ExternalMemoryHandleTypeFlagBitsNV> ExternalMemoryHandleTypeFlagBitsNV = {
|
|
{ "OpaqueWin32", ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 },
|
|
{ "OpaqueWin32Kmt", ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt },
|
|
{ "D3D11Image", ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image },
|
|
{ "D3D11ImageKmt", ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ExternalMemoryFeatureFlagBitsNV> ExternalMemoryFeatureFlagBitsNV = {
|
|
{ "DedicatedOnly", ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly },
|
|
{ "Exportable", ExternalMemoryFeatureFlagBitsNV::eExportable },
|
|
{ "Importable", ExternalMemoryFeatureFlagBitsNV::eImportable },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_validation_flags ===
|
|
|
|
std::unordered_map<std::string, ValidationCheckEXT> ValidationCheckEXT = {
|
|
{ "All", ValidationCheckEXT::eAll },
|
|
{ "Shaders", ValidationCheckEXT::eShaders },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_VI_NN )
|
|
//=== VK_NN_vi_surface ===
|
|
|
|
std::unordered_map<std::string, ViSurfaceCreateFlagBitsNN> ViSurfaceCreateFlagBitsNN = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
|
//=== VK_EXT_pipeline_robustness ===
|
|
|
|
std::unordered_map<std::string, PipelineRobustnessBufferBehaviorEXT> PipelineRobustnessBufferBehaviorEXT = {
|
|
{ "DeviceDefault", PipelineRobustnessBufferBehaviorEXT::eDeviceDefault },
|
|
{ "Disabled", PipelineRobustnessBufferBehaviorEXT::eDisabled },
|
|
{ "RobustBufferAccess", PipelineRobustnessBufferBehaviorEXT::eRobustBufferAccess },
|
|
{ "RobustBufferAccess2", PipelineRobustnessBufferBehaviorEXT::eRobustBufferAccess2 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineRobustnessImageBehaviorEXT> PipelineRobustnessImageBehaviorEXT = {
|
|
{ "DeviceDefault", PipelineRobustnessImageBehaviorEXT::eDeviceDefault },
|
|
{ "Disabled", PipelineRobustnessImageBehaviorEXT::eDisabled },
|
|
{ "RobustImageAccess", PipelineRobustnessImageBehaviorEXT::eRobustImageAccess },
|
|
{ "RobustImageAccess2", PipelineRobustnessImageBehaviorEXT::eRobustImageAccess2 },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_conditional_rendering ===
|
|
|
|
std::unordered_map<std::string, ConditionalRenderingFlagBitsEXT> ConditionalRenderingFlagBitsEXT = {
|
|
{ "Inverted", ConditionalRenderingFlagBitsEXT::eInverted },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_display_surface_counter ===
|
|
|
|
std::unordered_map<std::string, SurfaceCounterFlagBitsEXT> SurfaceCounterFlagBitsEXT = {
|
|
{ "Vblank", SurfaceCounterFlagBitsEXT::eVblank },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_display_control ===
|
|
|
|
std::unordered_map<std::string, DisplayPowerStateEXT> DisplayPowerStateEXT = {
|
|
{ "Off", DisplayPowerStateEXT::eOff },
|
|
{ "Suspend", DisplayPowerStateEXT::eSuspend },
|
|
{ "On", DisplayPowerStateEXT::eOn },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceEventTypeEXT> DeviceEventTypeEXT = {
|
|
{ "DisplayHotplug", DeviceEventTypeEXT::eDisplayHotplug },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DisplayEventTypeEXT> DisplayEventTypeEXT = {
|
|
{ "FirstPixelOut", DisplayEventTypeEXT::eFirstPixelOut },
|
|
|
|
};
|
|
|
|
//=== VK_NV_viewport_swizzle ===
|
|
|
|
std::unordered_map<std::string, ViewportCoordinateSwizzleNV> ViewportCoordinateSwizzleNV = {
|
|
{ "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> PipelineViewportSwizzleStateCreateFlagBitsNV = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_discard_rectangles ===
|
|
|
|
std::unordered_map<std::string, DiscardRectangleModeEXT> DiscardRectangleModeEXT = {
|
|
{ "Inclusive", DiscardRectangleModeEXT::eInclusive },
|
|
{ "Exclusive", DiscardRectangleModeEXT::eExclusive },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineDiscardRectangleStateCreateFlagBitsEXT> PipelineDiscardRectangleStateCreateFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_conservative_rasterization ===
|
|
|
|
std::unordered_map<std::string, ConservativeRasterizationModeEXT> ConservativeRasterizationModeEXT = {
|
|
{ "Disabled", ConservativeRasterizationModeEXT::eDisabled },
|
|
{ "Overestimate", ConservativeRasterizationModeEXT::eOverestimate },
|
|
{ "Underestimate", ConservativeRasterizationModeEXT::eUnderestimate },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationConservativeStateCreateFlagBitsEXT> PipelineRasterizationConservativeStateCreateFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_depth_clip_enable ===
|
|
|
|
std::unordered_map<std::string, PipelineRasterizationDepthClipStateCreateFlagBitsEXT> PipelineRasterizationDepthClipStateCreateFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
//=== VK_KHR_performance_query ===
|
|
|
|
std::unordered_map<std::string, PerformanceCounterDescriptionFlagBitsKHR> PerformanceCounterDescriptionFlagBitsKHR = {
|
|
{ "PerformanceImpacting", PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting },
|
|
{ "ConcurrentlyImpacted", PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceCounterScopeKHR> PerformanceCounterScopeKHR = {
|
|
{ "CommandBuffer", PerformanceCounterScopeKHR::eCommandBuffer },
|
|
{ "RenderPass", PerformanceCounterScopeKHR::eRenderPass },
|
|
{ "Command", PerformanceCounterScopeKHR::eCommand },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceCounterStorageKHR> PerformanceCounterStorageKHR = {
|
|
{ "Int32", PerformanceCounterStorageKHR::eInt32 }, { "Int64", PerformanceCounterStorageKHR::eInt64 },
|
|
{ "Uint32", PerformanceCounterStorageKHR::eUint32 }, { "Uint64", PerformanceCounterStorageKHR::eUint64 },
|
|
{ "Float32", PerformanceCounterStorageKHR::eFloat32 }, { "Float64", PerformanceCounterStorageKHR::eFloat64 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceCounterUnitKHR> PerformanceCounterUnitKHR = {
|
|
{ "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> AcquireProfilingLockFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
//=== VK_MVK_ios_surface ===
|
|
|
|
std::unordered_map<std::string, IOSSurfaceCreateFlagBitsMVK> IOSSurfaceCreateFlagBitsMVK = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
|
#if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
//=== VK_MVK_macos_surface ===
|
|
|
|
std::unordered_map<std::string, MacOSSurfaceCreateFlagBitsMVK> MacOSSurfaceCreateFlagBitsMVK = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
|
//=== VK_EXT_debug_utils ===
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessageSeverityFlagBitsEXT> DebugUtilsMessageSeverityFlagBitsEXT = {
|
|
{ "Verbose", DebugUtilsMessageSeverityFlagBitsEXT::eVerbose },
|
|
{ "Info", DebugUtilsMessageSeverityFlagBitsEXT::eInfo },
|
|
{ "Warning", DebugUtilsMessageSeverityFlagBitsEXT::eWarning },
|
|
{ "Error", DebugUtilsMessageSeverityFlagBitsEXT::eError },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessageTypeFlagBitsEXT> DebugUtilsMessageTypeFlagBitsEXT = {
|
|
{ "General", DebugUtilsMessageTypeFlagBitsEXT::eGeneral },
|
|
{ "Validation", DebugUtilsMessageTypeFlagBitsEXT::eValidation },
|
|
{ "Performance", DebugUtilsMessageTypeFlagBitsEXT::ePerformance },
|
|
{ "DeviceAddressBinding", DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessengerCallbackDataFlagBitsEXT> DebugUtilsMessengerCallbackDataFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DebugUtilsMessengerCreateFlagBitsEXT> DebugUtilsMessengerCreateFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_blend_operation_advanced ===
|
|
|
|
std::unordered_map<std::string, BlendOverlapEXT> BlendOverlapEXT = {
|
|
{ "Uncorrelated", BlendOverlapEXT::eUncorrelated },
|
|
{ "Disjoint", BlendOverlapEXT::eDisjoint },
|
|
{ "Conjoint", BlendOverlapEXT::eConjoint },
|
|
|
|
};
|
|
|
|
//=== VK_NV_fragment_coverage_to_color ===
|
|
|
|
std::unordered_map<std::string, PipelineCoverageToColorStateCreateFlagBitsNV> PipelineCoverageToColorStateCreateFlagBitsNV = {
|
|
|
|
};
|
|
|
|
//=== VK_KHR_acceleration_structure ===
|
|
|
|
std::unordered_map<std::string, AccelerationStructureTypeKHR> AccelerationStructureTypeKHR = {
|
|
{ "TopLevel", AccelerationStructureTypeKHR::eTopLevel },
|
|
{ "BottomLevel", AccelerationStructureTypeKHR::eBottomLevel },
|
|
{ "Generic", AccelerationStructureTypeKHR::eGeneric },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureBuildTypeKHR> AccelerationStructureBuildTypeKHR = {
|
|
{ "Host", AccelerationStructureBuildTypeKHR::eHost },
|
|
{ "Device", AccelerationStructureBuildTypeKHR::eDevice },
|
|
{ "HostOrDevice", AccelerationStructureBuildTypeKHR::eHostOrDevice },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, GeometryFlagBitsKHR> GeometryFlagBitsKHR = {
|
|
{ "Opaque", GeometryFlagBitsKHR::eOpaque },
|
|
{ "NoDuplicateAnyHitInvocation", GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, GeometryInstanceFlagBitsKHR> GeometryInstanceFlagBitsKHR = {
|
|
{ "TriangleFacingCullDisable", GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable },
|
|
{ "TriangleFlipFacing", GeometryInstanceFlagBitsKHR::eTriangleFlipFacing },
|
|
{ "ForceOpaque", GeometryInstanceFlagBitsKHR::eForceOpaque },
|
|
{ "ForceNoOpaque", GeometryInstanceFlagBitsKHR::eForceNoOpaque },
|
|
{ "ForceOpacityMicromap2StateEXT", GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT },
|
|
{ "DisableOpacityMicromapsEXT", GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildAccelerationStructureFlagBitsKHR> BuildAccelerationStructureFlagBitsKHR = {
|
|
{ "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> CopyAccelerationStructureModeKHR = {
|
|
{ "Clone", CopyAccelerationStructureModeKHR::eClone },
|
|
{ "Compact", CopyAccelerationStructureModeKHR::eCompact },
|
|
{ "Serialize", CopyAccelerationStructureModeKHR::eSerialize },
|
|
{ "Deserialize", CopyAccelerationStructureModeKHR::eDeserialize },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, GeometryTypeKHR> GeometryTypeKHR = {
|
|
{ "Triangles", GeometryTypeKHR::eTriangles },
|
|
{ "Aabbs", GeometryTypeKHR::eAabbs },
|
|
{ "Instances", GeometryTypeKHR::eInstances },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureCompatibilityKHR> AccelerationStructureCompatibilityKHR = {
|
|
{ "Compatible", AccelerationStructureCompatibilityKHR::eCompatible },
|
|
{ "Incompatible", AccelerationStructureCompatibilityKHR::eIncompatible },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureCreateFlagBitsKHR> AccelerationStructureCreateFlagBitsKHR = {
|
|
{ "DeviceAddressCaptureReplay", AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay },
|
|
{ "DescriptorBufferCaptureReplayEXT", AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT },
|
|
{ "MotionNV", AccelerationStructureCreateFlagBitsKHR::eMotionNV },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildAccelerationStructureModeKHR> BuildAccelerationStructureModeKHR = {
|
|
{ "Build", BuildAccelerationStructureModeKHR::eBuild },
|
|
{ "Update", BuildAccelerationStructureModeKHR::eUpdate },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_ray_tracing_pipeline ===
|
|
|
|
std::unordered_map<std::string, RayTracingShaderGroupTypeKHR> RayTracingShaderGroupTypeKHR = {
|
|
{ "General", RayTracingShaderGroupTypeKHR::eGeneral },
|
|
{ "TrianglesHitGroup", RayTracingShaderGroupTypeKHR::eTrianglesHitGroup },
|
|
{ "ProceduralHitGroup", RayTracingShaderGroupTypeKHR::eProceduralHitGroup },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ShaderGroupShaderKHR> ShaderGroupShaderKHR = {
|
|
{ "General", ShaderGroupShaderKHR::eGeneral },
|
|
{ "ClosestHit", ShaderGroupShaderKHR::eClosestHit },
|
|
{ "AnyHit", ShaderGroupShaderKHR::eAnyHit },
|
|
{ "Intersection", ShaderGroupShaderKHR::eIntersection },
|
|
|
|
};
|
|
|
|
//=== VK_NV_framebuffer_mixed_samples ===
|
|
|
|
std::unordered_map<std::string, CoverageModulationModeNV> CoverageModulationModeNV = {
|
|
{ "None", CoverageModulationModeNV::eNone },
|
|
{ "Rgb", CoverageModulationModeNV::eRgb },
|
|
{ "Alpha", CoverageModulationModeNV::eAlpha },
|
|
{ "Rgba", CoverageModulationModeNV::eRgba },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCoverageModulationStateCreateFlagBitsNV> PipelineCoverageModulationStateCreateFlagBitsNV = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_validation_cache ===
|
|
|
|
std::unordered_map<std::string, ValidationCacheHeaderVersionEXT> ValidationCacheHeaderVersionEXT = {
|
|
{ "One", ValidationCacheHeaderVersionEXT::eOne },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ValidationCacheCreateFlagBitsEXT> ValidationCacheCreateFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
//=== VK_NV_shading_rate_image ===
|
|
|
|
std::unordered_map<std::string, ShadingRatePaletteEntryNV> ShadingRatePaletteEntryNV = {
|
|
{ "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> CoarseSampleOrderTypeNV = {
|
|
{ "Default", CoarseSampleOrderTypeNV::eDefault },
|
|
{ "Custom", CoarseSampleOrderTypeNV::eCustom },
|
|
{ "PixelMajor", CoarseSampleOrderTypeNV::ePixelMajor },
|
|
{ "SampleMajor", CoarseSampleOrderTypeNV::eSampleMajor },
|
|
|
|
};
|
|
|
|
//=== VK_NV_ray_tracing ===
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMemoryRequirementsTypeNV> AccelerationStructureMemoryRequirementsTypeNV = {
|
|
{ "Object", AccelerationStructureMemoryRequirementsTypeNV::eObject },
|
|
{ "BuildScratch", AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch },
|
|
{ "UpdateScratch", AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch },
|
|
|
|
};
|
|
|
|
//=== VK_AMD_pipeline_compiler_control ===
|
|
|
|
std::unordered_map<std::string, PipelineCompilerControlFlagBitsAMD> PipelineCompilerControlFlagBitsAMD = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_calibrated_timestamps ===
|
|
|
|
std::unordered_map<std::string, TimeDomainEXT> TimeDomainEXT = {
|
|
{ "Device", TimeDomainEXT::eDevice },
|
|
{ "ClockMonotonic", TimeDomainEXT::eClockMonotonic },
|
|
{ "ClockMonotonicRaw", TimeDomainEXT::eClockMonotonicRaw },
|
|
{ "QueryPerformanceCounter", TimeDomainEXT::eQueryPerformanceCounter },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_global_priority ===
|
|
|
|
std::unordered_map<std::string, QueueGlobalPriorityKHR> QueueGlobalPriorityKHR = {
|
|
{ "Low", QueueGlobalPriorityKHR::eLow },
|
|
{ "Medium", QueueGlobalPriorityKHR::eMedium },
|
|
{ "High", QueueGlobalPriorityKHR::eHigh },
|
|
{ "Realtime", QueueGlobalPriorityKHR::eRealtime },
|
|
|
|
};
|
|
|
|
//=== VK_AMD_memory_overallocation_behavior ===
|
|
|
|
std::unordered_map<std::string, MemoryOverallocationBehaviorAMD> MemoryOverallocationBehaviorAMD = {
|
|
{ "Default", MemoryOverallocationBehaviorAMD::eDefault },
|
|
{ "Allowed", MemoryOverallocationBehaviorAMD::eAllowed },
|
|
{ "Disallowed", MemoryOverallocationBehaviorAMD::eDisallowed },
|
|
|
|
};
|
|
|
|
//=== VK_INTEL_performance_query ===
|
|
|
|
std::unordered_map<std::string, PerformanceConfigurationTypeINTEL> PerformanceConfigurationTypeINTEL = {
|
|
{ "CommandQueueMetricsDiscoveryActivated", PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, QueryPoolSamplingModeINTEL> QueryPoolSamplingModeINTEL = {
|
|
{ "Manual", QueryPoolSamplingModeINTEL::eManual },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceOverrideTypeINTEL> PerformanceOverrideTypeINTEL = {
|
|
{ "NullHardware", PerformanceOverrideTypeINTEL::eNullHardware },
|
|
{ "FlushGpuCaches", PerformanceOverrideTypeINTEL::eFlushGpuCaches },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceParameterTypeINTEL> PerformanceParameterTypeINTEL = {
|
|
{ "HwCountersSupported", PerformanceParameterTypeINTEL::eHwCountersSupported },
|
|
{ "StreamMarkerValidBits", PerformanceParameterTypeINTEL::eStreamMarkerValidBits },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PerformanceValueTypeINTEL> PerformanceValueTypeINTEL = {
|
|
{ "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> ImagePipeSurfaceCreateFlagBitsFUCHSIA = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
//=== VK_EXT_metal_surface ===
|
|
|
|
std::unordered_map<std::string, MetalSurfaceCreateFlagBitsEXT> MetalSurfaceCreateFlagBitsEXT = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
|
//=== VK_KHR_fragment_shading_rate ===
|
|
|
|
std::unordered_map<std::string, FragmentShadingRateCombinerOpKHR> FragmentShadingRateCombinerOpKHR = {
|
|
{ "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> ShaderCorePropertiesFlagBitsAMD = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_validation_features ===
|
|
|
|
std::unordered_map<std::string, ValidationFeatureEnableEXT> ValidationFeatureEnableEXT = {
|
|
{ "GpuAssisted", ValidationFeatureEnableEXT::eGpuAssisted },
|
|
{ "GpuAssistedReserveBindingSlot", ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot },
|
|
{ "BestPractices", ValidationFeatureEnableEXT::eBestPractices },
|
|
{ "DebugPrintf", ValidationFeatureEnableEXT::eDebugPrintf },
|
|
{ "SynchronizationValidation", ValidationFeatureEnableEXT::eSynchronizationValidation },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ValidationFeatureDisableEXT> ValidationFeatureDisableEXT = {
|
|
{ "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> CoverageReductionModeNV = {
|
|
{ "Merge", CoverageReductionModeNV::eMerge },
|
|
{ "Truncate", CoverageReductionModeNV::eTruncate },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PipelineCoverageReductionStateCreateFlagBitsNV> PipelineCoverageReductionStateCreateFlagBitsNV = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_provoking_vertex ===
|
|
|
|
std::unordered_map<std::string, ProvokingVertexModeEXT> ProvokingVertexModeEXT = {
|
|
{ "FirstVertex", ProvokingVertexModeEXT::eFirstVertex },
|
|
{ "LastVertex", ProvokingVertexModeEXT::eLastVertex },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_EXT_full_screen_exclusive ===
|
|
|
|
std::unordered_map<std::string, FullScreenExclusiveEXT> FullScreenExclusiveEXT = {
|
|
{ "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> HeadlessSurfaceCreateFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_line_rasterization ===
|
|
|
|
std::unordered_map<std::string, LineRasterizationModeEXT> LineRasterizationModeEXT = {
|
|
{ "Default", LineRasterizationModeEXT::eDefault },
|
|
{ "Rectangular", LineRasterizationModeEXT::eRectangular },
|
|
{ "Bresenham", LineRasterizationModeEXT::eBresenham },
|
|
{ "RectangularSmooth", LineRasterizationModeEXT::eRectangularSmooth },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_pipeline_executable_properties ===
|
|
|
|
std::unordered_map<std::string, PipelineExecutableStatisticFormatKHR> PipelineExecutableStatisticFormatKHR = {
|
|
{ "Bool32", PipelineExecutableStatisticFormatKHR::eBool32 },
|
|
{ "Int64", PipelineExecutableStatisticFormatKHR::eInt64 },
|
|
{ "Uint64", PipelineExecutableStatisticFormatKHR::eUint64 },
|
|
{ "Float64", PipelineExecutableStatisticFormatKHR::eFloat64 },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_host_image_copy ===
|
|
|
|
std::unordered_map<std::string, HostImageCopyFlagBitsEXT> HostImageCopyFlagBitsEXT = {
|
|
{ "Memcpy", HostImageCopyFlagBitsEXT::eMemcpy },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_map_memory2 ===
|
|
|
|
std::unordered_map<std::string, MemoryUnmapFlagBitsKHR> MemoryUnmapFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_surface_maintenance1 ===
|
|
|
|
std::unordered_map<std::string, PresentScalingFlagBitsEXT> PresentScalingFlagBitsEXT = {
|
|
{ "OneToOne", PresentScalingFlagBitsEXT::eOneToOne },
|
|
{ "AspectRatioStretch", PresentScalingFlagBitsEXT::eAspectRatioStretch },
|
|
{ "Stretch", PresentScalingFlagBitsEXT::eStretch },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, PresentGravityFlagBitsEXT> PresentGravityFlagBitsEXT = {
|
|
{ "Min", PresentGravityFlagBitsEXT::eMin },
|
|
{ "Max", PresentGravityFlagBitsEXT::eMax },
|
|
{ "Centered", PresentGravityFlagBitsEXT::eCentered },
|
|
|
|
};
|
|
|
|
//=== VK_NV_device_generated_commands ===
|
|
|
|
std::unordered_map<std::string, IndirectStateFlagBitsNV> IndirectStateFlagBitsNV = {
|
|
{ "FlagFrontface", IndirectStateFlagBitsNV::eFlagFrontface },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, IndirectCommandsTokenTypeNV> IndirectCommandsTokenTypeNV = {
|
|
{ "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> IndirectCommandsLayoutUsageFlagBitsNV = {
|
|
{ "ExplicitPreprocess", IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess },
|
|
{ "IndexedSequences", IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences },
|
|
{ "UnorderedSequences", IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_depth_bias_control ===
|
|
|
|
std::unordered_map<std::string, DepthBiasRepresentationEXT> DepthBiasRepresentationEXT = {
|
|
{ "LeastRepresentableValueFormat", DepthBiasRepresentationEXT::eLeastRepresentableValueFormat },
|
|
{ "LeastRepresentableValueForceUnorm", DepthBiasRepresentationEXT::eLeastRepresentableValueForceUnorm },
|
|
{ "Float", DepthBiasRepresentationEXT::eFloat },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_device_memory_report ===
|
|
|
|
std::unordered_map<std::string, DeviceMemoryReportEventTypeEXT> DeviceMemoryReportEventTypeEXT = {
|
|
{ "Allocate", DeviceMemoryReportEventTypeEXT::eAllocate },
|
|
{ "Free", DeviceMemoryReportEventTypeEXT::eFree },
|
|
{ "Import", DeviceMemoryReportEventTypeEXT::eImport },
|
|
{ "Unimport", DeviceMemoryReportEventTypeEXT::eUnimport },
|
|
{ "AllocationFailed", DeviceMemoryReportEventTypeEXT::eAllocationFailed },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceMemoryReportFlagBitsEXT> DeviceMemoryReportFlagBitsEXT = {
|
|
|
|
};
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_KHR_video_encode_queue ===
|
|
|
|
std::unordered_map<std::string, VideoEncodeCapabilityFlagBitsKHR> VideoEncodeCapabilityFlagBitsKHR = {
|
|
{ "PrecedingExternallyEncodedBytes", VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes },
|
|
{ "InsufficientstreamBufferRangeDetectionBit", VideoEncodeCapabilityFlagBitsKHR::eInsufficientstreamBufferRangeDetectionBit },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeFeedbackFlagBitsKHR> VideoEncodeFeedbackFlagBitsKHR = {
|
|
{ "streamBufferOffsetBit", VideoEncodeFeedbackFlagBitsKHR::estreamBufferOffsetBit },
|
|
{ "streamBytesWrittenBit", VideoEncodeFeedbackFlagBitsKHR::estreamBytesWrittenBit },
|
|
{ "streamHasOverridesBit", VideoEncodeFeedbackFlagBitsKHR::estreamHasOverridesBit },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeUsageFlagBitsKHR> VideoEncodeUsageFlagBitsKHR = {
|
|
{ "Default", VideoEncodeUsageFlagBitsKHR::eDefault }, { "Transcoding", VideoEncodeUsageFlagBitsKHR::eTranscoding },
|
|
{ "Streaming", VideoEncodeUsageFlagBitsKHR::eStreaming }, { "Recording", VideoEncodeUsageFlagBitsKHR::eRecording },
|
|
{ "Conferencing", VideoEncodeUsageFlagBitsKHR::eConferencing },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeContentFlagBitsKHR> VideoEncodeContentFlagBitsKHR = {
|
|
{ "Default", VideoEncodeContentFlagBitsKHR::eDefault },
|
|
{ "Camera", VideoEncodeContentFlagBitsKHR::eCamera },
|
|
{ "Desktop", VideoEncodeContentFlagBitsKHR::eDesktop },
|
|
{ "Rendered", VideoEncodeContentFlagBitsKHR::eRendered },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeTuningModeKHR> VideoEncodeTuningModeKHR = {
|
|
{ "Default", VideoEncodeTuningModeKHR::eDefault }, { "HighQuality", VideoEncodeTuningModeKHR::eHighQuality },
|
|
{ "LowLatency", VideoEncodeTuningModeKHR::eLowLatency }, { "UltraLowLatency", VideoEncodeTuningModeKHR::eUltraLowLatency },
|
|
{ "Lossless", VideoEncodeTuningModeKHR::eLossless },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeRateControlModeFlagBitsKHR> VideoEncodeRateControlModeFlagBitsKHR = {
|
|
{ "Default", VideoEncodeRateControlModeFlagBitsKHR::eDefault },
|
|
{ "Disabled", VideoEncodeRateControlModeFlagBitsKHR::eDisabled },
|
|
{ "Cbr", VideoEncodeRateControlModeFlagBitsKHR::eCbr },
|
|
{ "Vbr", VideoEncodeRateControlModeFlagBitsKHR::eVbr },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeFlagBitsKHR> VideoEncodeFlagBitsKHR = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, VideoEncodeRateControlFlagBitsKHR> VideoEncodeRateControlFlagBitsKHR = {
|
|
|
|
};
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_NV_device_diagnostics_config ===
|
|
|
|
std::unordered_map<std::string, DeviceDiagnosticsConfigFlagBitsNV> DeviceDiagnosticsConfigFlagBitsNV = {
|
|
{ "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> ExportMetalObjectTypeFlagBitsEXT = {
|
|
{ "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> GraphicsPipelineLibraryFlagBitsEXT = {
|
|
{ "VertexInputInterface", GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface },
|
|
{ "PreRasterizationShaders", GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders },
|
|
{ "FragmentShader", GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader },
|
|
{ "FragmentOutputInterface", GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface },
|
|
|
|
};
|
|
|
|
//=== VK_NV_fragment_shading_rate_enums ===
|
|
|
|
std::unordered_map<std::string, FragmentShadingRateNV> FragmentShadingRateNV = {
|
|
{ "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> FragmentShadingRateTypeNV = {
|
|
{ "FragmentSize", FragmentShadingRateTypeNV::eFragmentSize },
|
|
{ "Enums", FragmentShadingRateTypeNV::eEnums },
|
|
|
|
};
|
|
|
|
//=== VK_NV_ray_tracing_motion_blur ===
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMotionInstanceTypeNV> AccelerationStructureMotionInstanceTypeNV = {
|
|
{ "Static", AccelerationStructureMotionInstanceTypeNV::eStatic },
|
|
{ "MatrixMotion", AccelerationStructureMotionInstanceTypeNV::eMatrixMotion },
|
|
{ "SrtMotion", AccelerationStructureMotionInstanceTypeNV::eSrtMotion },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMotionInfoFlagBitsNV> AccelerationStructureMotionInfoFlagBitsNV = {
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, AccelerationStructureMotionInstanceFlagBitsNV> AccelerationStructureMotionInstanceFlagBitsNV = {
|
|
|
|
};
|
|
|
|
//=== VK_EXT_image_compression_control ===
|
|
|
|
std::unordered_map<std::string, ImageCompressionFlagBitsEXT> ImageCompressionFlagBitsEXT = {
|
|
{ "Default", ImageCompressionFlagBitsEXT::eDefault },
|
|
{ "FixedRateDefault", ImageCompressionFlagBitsEXT::eFixedRateDefault },
|
|
{ "FixedRateExplicit", ImageCompressionFlagBitsEXT::eFixedRateExplicit },
|
|
{ "Disabled", ImageCompressionFlagBitsEXT::eDisabled },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageCompressionFixedRateFlagBitsEXT> ImageCompressionFixedRateFlagBitsEXT = {
|
|
{ "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> DeviceFaultAddressTypeEXT = {
|
|
{ "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> DeviceFaultVendorBinaryHeaderVersionEXT = {
|
|
{ "One", DeviceFaultVendorBinaryHeaderVersionEXT::eOne },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
//=== VK_EXT_directfb_surface ===
|
|
|
|
std::unordered_map<std::string, DirectFBSurfaceCreateFlagBitsEXT> DirectFBSurfaceCreateFlagBitsEXT = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
|
//=== VK_EXT_device_address_binding_report ===
|
|
|
|
std::unordered_map<std::string, DeviceAddressBindingFlagBitsEXT> DeviceAddressBindingFlagBitsEXT = {
|
|
{ "InternalObject", DeviceAddressBindingFlagBitsEXT::eInternalObject },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DeviceAddressBindingTypeEXT> DeviceAddressBindingTypeEXT = {
|
|
{ "Bind", DeviceAddressBindingTypeEXT::eBind },
|
|
{ "Unbind", DeviceAddressBindingTypeEXT::eUnbind },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_buffer_collection ===
|
|
|
|
std::unordered_map<std::string, ImageConstraintsInfoFlagBitsFUCHSIA> ImageConstraintsInfoFlagBitsFUCHSIA = {
|
|
{ "CpuReadRarely", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely },
|
|
{ "CpuReadOften", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften },
|
|
{ "CpuWriteRarely", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely },
|
|
{ "CpuWriteOften", ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften },
|
|
{ "ProtectedOptional", ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ImageFormatConstraintsFlagBitsFUCHSIA> ImageFormatConstraintsFlagBitsFUCHSIA = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
//=== VK_EXT_frame_boundary ===
|
|
|
|
std::unordered_map<std::string, FrameBoundaryFlagBitsEXT> FrameBoundaryFlagBitsEXT = {
|
|
{ "FrameEnd", FrameBoundaryFlagBitsEXT::eFrameEnd },
|
|
|
|
};
|
|
|
|
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
//=== VK_QNX_screen_surface ===
|
|
|
|
std::unordered_map<std::string, ScreenSurfaceCreateFlagBitsQNX> ScreenSurfaceCreateFlagBitsQNX = {
|
|
|
|
};
|
|
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
|
//=== VK_EXT_opacity_micromap ===
|
|
|
|
std::unordered_map<std::string, MicromapTypeEXT> MicromapTypeEXT = {
|
|
{ "OpacityMicromap", MicromapTypeEXT::eOpacityMicromap },
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
{ "DisplacementMicromapNV", MicromapTypeEXT::eDisplacementMicromapNV },
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildMicromapFlagBitsEXT> BuildMicromapFlagBitsEXT = {
|
|
{ "PreferFastTrace", BuildMicromapFlagBitsEXT::ePreferFastTrace },
|
|
{ "PreferFastBuild", BuildMicromapFlagBitsEXT::ePreferFastBuild },
|
|
{ "AllowCompaction", BuildMicromapFlagBitsEXT::eAllowCompaction },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, CopyMicromapModeEXT> CopyMicromapModeEXT = {
|
|
{ "Clone", CopyMicromapModeEXT::eClone },
|
|
{ "Serialize", CopyMicromapModeEXT::eSerialize },
|
|
{ "Deserialize", CopyMicromapModeEXT::eDeserialize },
|
|
{ "Compact", CopyMicromapModeEXT::eCompact },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, MicromapCreateFlagBitsEXT> MicromapCreateFlagBitsEXT = {
|
|
{ "DeviceAddressCaptureReplay", MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, BuildMicromapModeEXT> BuildMicromapModeEXT = {
|
|
{ "Build", BuildMicromapModeEXT::eBuild },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpacityMicromapFormatEXT> OpacityMicromapFormatEXT = {
|
|
{ "2State", OpacityMicromapFormatEXT::e2State },
|
|
{ "4State", OpacityMicromapFormatEXT::e4State },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpacityMicromapSpecialIndexEXT> OpacityMicromapSpecialIndexEXT = {
|
|
{ "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> DisplacementMicromapFormatNV = {
|
|
{ "64Triangles64Bytes", DisplacementMicromapFormatNV::e64Triangles64Bytes },
|
|
{ "256Triangles128Bytes", DisplacementMicromapFormatNV::e256Triangles128Bytes },
|
|
{ "1024Triangles128Bytes", DisplacementMicromapFormatNV::e1024Triangles128Bytes },
|
|
|
|
};
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_ARM_scheduling_controls ===
|
|
|
|
std::unordered_map<std::string, PhysicalDeviceSchedulingControlsFlagBitsARM> PhysicalDeviceSchedulingControlsFlagBitsARM = {
|
|
{ "ShaderCoreCount", PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount },
|
|
|
|
};
|
|
|
|
//=== VK_NV_memory_decompression ===
|
|
|
|
std::unordered_map<std::string, MemoryDecompressionMethodFlagBitsNV> MemoryDecompressionMethodFlagBitsNV = {
|
|
{ "Gdeflate10", MemoryDecompressionMethodFlagBitsNV::eGdeflate10 },
|
|
|
|
};
|
|
|
|
//=== VK_EXT_subpass_merge_feedback ===
|
|
|
|
std::unordered_map<std::string, SubpassMergeStatusEXT> SubpassMergeStatusEXT = {
|
|
{ "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> DirectDriverLoadingModeLUNARG = {
|
|
{ "Exclusive", DirectDriverLoadingModeLUNARG::eExclusive },
|
|
{ "Inclusive", DirectDriverLoadingModeLUNARG::eInclusive },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, DirectDriverLoadingFlagBitsLUNARG> DirectDriverLoadingFlagBitsLUNARG = {
|
|
|
|
};
|
|
|
|
//=== VK_NV_optical_flow ===
|
|
|
|
std::unordered_map<std::string, OpticalFlowUsageFlagBitsNV> OpticalFlowUsageFlagBitsNV = {
|
|
{ "Unknown", OpticalFlowUsageFlagBitsNV::eUnknown }, { "Input", OpticalFlowUsageFlagBitsNV::eInput },
|
|
{ "Output", OpticalFlowUsageFlagBitsNV::eOutput }, { "Hint", OpticalFlowUsageFlagBitsNV::eHint },
|
|
{ "Cost", OpticalFlowUsageFlagBitsNV::eCost }, { "GlobalFlow", OpticalFlowUsageFlagBitsNV::eGlobalFlow },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowGridSizeFlagBitsNV> OpticalFlowGridSizeFlagBitsNV = {
|
|
{ "Unknown", OpticalFlowGridSizeFlagBitsNV::eUnknown }, { "1X1", OpticalFlowGridSizeFlagBitsNV::e1X1 }, { "2X2", OpticalFlowGridSizeFlagBitsNV::e2X2 },
|
|
{ "4X4", OpticalFlowGridSizeFlagBitsNV::e4X4 }, { "8X8", OpticalFlowGridSizeFlagBitsNV::e8X8 },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowPerformanceLevelNV> OpticalFlowPerformanceLevelNV = {
|
|
{ "Unknown", OpticalFlowPerformanceLevelNV::eUnknown },
|
|
{ "Slow", OpticalFlowPerformanceLevelNV::eSlow },
|
|
{ "Medium", OpticalFlowPerformanceLevelNV::eMedium },
|
|
{ "Fast", OpticalFlowPerformanceLevelNV::eFast },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowSessionBindingPointNV> OpticalFlowSessionBindingPointNV = {
|
|
{ "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> OpticalFlowSessionCreateFlagBitsNV = {
|
|
{ "EnableHint", OpticalFlowSessionCreateFlagBitsNV::eEnableHint },
|
|
{ "EnableCost", OpticalFlowSessionCreateFlagBitsNV::eEnableCost },
|
|
{ "EnableGlobalFlow", OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow },
|
|
{ "AllowRegions", OpticalFlowSessionCreateFlagBitsNV::eAllowRegions },
|
|
{ "BothDirections", OpticalFlowSessionCreateFlagBitsNV::eBothDirections },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, OpticalFlowExecuteFlagBitsNV> OpticalFlowExecuteFlagBitsNV = {
|
|
{ "DisableTemporalHints", OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_maintenance5 ===
|
|
|
|
std::unordered_map<std::string, PipelineCreateFlagBits2KHR> PipelineCreateFlagBits2KHR = {
|
|
{ "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> BufferUsageFlagBits2KHR = {
|
|
{ "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> ShaderCreateFlagBitsEXT = {
|
|
{ "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> ShaderCodeTypeEXT = {
|
|
{ "Binary", ShaderCodeTypeEXT::eBinary },
|
|
{ "Spirv", ShaderCodeTypeEXT::eSpirv },
|
|
|
|
};
|
|
|
|
//=== VK_NV_ray_tracing_invocation_reorder ===
|
|
|
|
std::unordered_map<std::string, RayTracingInvocationReorderModeNV> RayTracingInvocationReorderModeNV = {
|
|
{ "None", RayTracingInvocationReorderModeNV::eNone },
|
|
{ "Reorder", RayTracingInvocationReorderModeNV::eReorder },
|
|
|
|
};
|
|
|
|
//=== VK_NV_low_latency2 ===
|
|
|
|
std::unordered_map<std::string, LatencyMarkerNV> LatencyMarkerNV = {
|
|
{ "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> OutOfBandQueueTypeNV = {
|
|
{ "Render", OutOfBandQueueTypeNV::eRender },
|
|
{ "Present", OutOfBandQueueTypeNV::ePresent },
|
|
|
|
};
|
|
|
|
//=== VK_KHR_cooperative_matrix ===
|
|
|
|
std::unordered_map<std::string, ScopeKHR> ScopeKHR = {
|
|
{ "Device", ScopeKHR::eDevice },
|
|
{ "Workgroup", ScopeKHR::eWorkgroup },
|
|
{ "Subgroup", ScopeKHR::eSubgroup },
|
|
{ "QueueFamily", ScopeKHR::eQueueFamily },
|
|
|
|
};
|
|
|
|
std::unordered_map<std::string, ComponentTypeKHR> ComponentTypeKHR = {
|
|
{ "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> BlockMatchWindowCompareModeQCOM = {
|
|
{ "Min", BlockMatchWindowCompareModeQCOM::eMin },
|
|
{ "Max", BlockMatchWindowCompareModeQCOM::eMax },
|
|
|
|
};
|
|
|
|
//=== VK_QCOM_filter_cubic_weights ===
|
|
|
|
std::unordered_map<std::string, CubicFilterWeightsQCOM> CubicFilterWeightsQCOM = {
|
|
{ "CatmullRom", CubicFilterWeightsQCOM::eCatmullRom },
|
|
{ "ZeroTangentCardinal", CubicFilterWeightsQCOM::eZeroTangentCardinal },
|
|
{ "BSpline", CubicFilterWeightsQCOM::eBSpline },
|
|
{ "MitchellNetravali", CubicFilterWeightsQCOM::eMitchellNetravali },
|
|
|
|
};
|
|
|
|
//=== VK_MSFT_layered_driver ===
|
|
|
|
std::unordered_map<std::string, LayeredDriverUnderlyingApiMSFT> LayeredDriverUnderlyingApiMSFT = {
|
|
{ "None", LayeredDriverUnderlyingApiMSFT::eNone },
|
|
{ "D3D12", LayeredDriverUnderlyingApiMSFT::eD3D12 },
|
|
|
|
};
|
|
};
|
|
|
|
VULKAN_HPP_STORAGE_API extern const EnumFromStringMap enumFromStringMap;
|
|
|
|
//=== VK_VERSION_1_0 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<Result> Result_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.Result.find( value );
|
|
if ( it != enumFromStringMap.Result.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<StructureType> StructureType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.StructureType.find( value );
|
|
if ( it != enumFromStringMap.StructureType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCacheHeaderVersion> PipelineCacheHeaderVersion_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCacheHeaderVersion.find( value );
|
|
if ( it != enumFromStringMap.PipelineCacheHeaderVersion.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ObjectType> ObjectType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ObjectType.find( value );
|
|
if ( it != enumFromStringMap.ObjectType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VendorId> VendorId_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VendorId.find( value );
|
|
if ( it != enumFromStringMap.VendorId.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<Format> Format_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.Format.find( value );
|
|
if ( it != enumFromStringMap.Format.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<FormatFeatureFlagBits> FormatFeatureFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FormatFeatureFlagBits.find( value );
|
|
if ( it != enumFromStringMap.FormatFeatureFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageCreateFlagBits> ImageCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ImageCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageTiling> ImageTiling_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageTiling.find( value );
|
|
if ( it != enumFromStringMap.ImageTiling.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageType> ImageType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageType.find( value );
|
|
if ( it != enumFromStringMap.ImageType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageUsageFlagBits> ImageUsageFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageUsageFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ImageUsageFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<InstanceCreateFlagBits> InstanceCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.InstanceCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.InstanceCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<InternalAllocationType> InternalAllocationType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.InternalAllocationType.find( value );
|
|
if ( it != enumFromStringMap.InternalAllocationType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<MemoryHeapFlagBits> MemoryHeapFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryHeapFlagBits.find( value );
|
|
if ( it != enumFromStringMap.MemoryHeapFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<MemoryPropertyFlagBits> MemoryPropertyFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryPropertyFlagBits.find( value );
|
|
if ( it != enumFromStringMap.MemoryPropertyFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PhysicalDeviceType> PhysicalDeviceType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PhysicalDeviceType.find( value );
|
|
if ( it != enumFromStringMap.PhysicalDeviceType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueueFlagBits> QueueFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueueFlagBits.find( value );
|
|
if ( it != enumFromStringMap.QueueFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SampleCountFlagBits> SampleCountFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SampleCountFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SampleCountFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SystemAllocationScope> SystemAllocationScope_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SystemAllocationScope.find( value );
|
|
if ( it != enumFromStringMap.SystemAllocationScope.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceCreateFlagBits> DeviceCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceQueueCreateFlagBits> DeviceQueueCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceQueueCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.DeviceQueueCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineStageFlagBits> PipelineStageFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineStageFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineStageFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<MemoryMapFlagBits> MemoryMapFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageAspectFlagBits> ImageAspectFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageAspectFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ImageAspectFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SparseImageFormatFlagBits> SparseImageFormatFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SparseImageFormatFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SparseImageFormatFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SparseMemoryBindFlagBits> SparseMemoryBindFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SparseMemoryBindFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SparseMemoryBindFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<FenceCreateFlagBits> FenceCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FenceCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.FenceCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreCreateFlagBits> SemaphoreCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<EventCreateFlagBits> EventCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.EventCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.EventCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueryPipelineStatisticFlagBits> QueryPipelineStatisticFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryPipelineStatisticFlagBits.find( value );
|
|
if ( it != enumFromStringMap.QueryPipelineStatisticFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueryResultFlagBits> QueryResultFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryResultFlagBits.find( value );
|
|
if ( it != enumFromStringMap.QueryResultFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueryType> QueryType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryType.find( value );
|
|
if ( it != enumFromStringMap.QueryType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueryPoolCreateFlagBits> QueryPoolCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BufferCreateFlagBits> BufferCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BufferCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.BufferCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BufferUsageFlagBits> BufferUsageFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BufferUsageFlagBits.find( value );
|
|
if ( it != enumFromStringMap.BufferUsageFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SharingMode> SharingMode_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SharingMode.find( value );
|
|
if ( it != enumFromStringMap.SharingMode.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BufferViewCreateFlagBits> BufferViewCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageLayout> ImageLayout_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageLayout.find( value );
|
|
if ( it != enumFromStringMap.ImageLayout.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ComponentSwizzle> ComponentSwizzle_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ComponentSwizzle.find( value );
|
|
if ( it != enumFromStringMap.ComponentSwizzle.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageViewCreateFlagBits> ImageViewCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageViewCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ImageViewCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageViewType> ImageViewType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageViewType.find( value );
|
|
if ( it != enumFromStringMap.ImageViewType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderModuleCreateFlagBits> ShaderModuleCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCacheCreateFlagBits> PipelineCacheCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCacheCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineCacheCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BlendFactor> BlendFactor_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlendFactor.find( value );
|
|
if ( it != enumFromStringMap.BlendFactor.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BlendOp> BlendOp_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlendOp.find( value );
|
|
if ( it != enumFromStringMap.BlendOp.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ColorComponentFlagBits> ColorComponentFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ColorComponentFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ColorComponentFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CompareOp> CompareOp_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CompareOp.find( value );
|
|
if ( it != enumFromStringMap.CompareOp.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CullModeFlagBits> CullModeFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CullModeFlagBits.find( value );
|
|
if ( it != enumFromStringMap.CullModeFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DynamicState> DynamicState_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DynamicState.find( value );
|
|
if ( it != enumFromStringMap.DynamicState.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<FrontFace> FrontFace_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FrontFace.find( value );
|
|
if ( it != enumFromStringMap.FrontFace.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<LogicOp> LogicOp_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LogicOp.find( value );
|
|
if ( it != enumFromStringMap.LogicOp.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCreateFlagBits> PipelineCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineShaderStageCreateFlagBits> PipelineShaderStageCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineShaderStageCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineShaderStageCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PolygonMode> PolygonMode_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PolygonMode.find( value );
|
|
if ( it != enumFromStringMap.PolygonMode.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PrimitiveTopology> PrimitiveTopology_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PrimitiveTopology.find( value );
|
|
if ( it != enumFromStringMap.PrimitiveTopology.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderStageFlagBits> ShaderStageFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderStageFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ShaderStageFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<StencilOp> StencilOp_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.StencilOp.find( value );
|
|
if ( it != enumFromStringMap.StencilOp.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VertexInputRate> VertexInputRate_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VertexInputRate.find( value );
|
|
if ( it != enumFromStringMap.VertexInputRate.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineColorBlendStateCreateFlagBits> PipelineColorBlendStateCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineColorBlendStateCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineColorBlendStateCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineDepthStencilStateCreateFlagBits> PipelineDepthStencilStateCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineDepthStencilStateCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineDepthStencilStateCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineDynamicStateCreateFlagBits> PipelineDynamicStateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineInputAssemblyStateCreateFlagBits> PipelineInputAssemblyStateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineLayoutCreateFlagBits> PipelineLayoutCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineLayoutCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineLayoutCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineMultisampleStateCreateFlagBits> PipelineMultisampleStateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationStateCreateFlagBits> PipelineRasterizationStateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineTessellationStateCreateFlagBits> PipelineTessellationStateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineVertexInputStateCreateFlagBits> PipelineVertexInputStateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineViewportStateCreateFlagBits> PipelineViewportStateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BorderColor> BorderColor_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BorderColor.find( value );
|
|
if ( it != enumFromStringMap.BorderColor.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<Filter> Filter_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.Filter.find( value );
|
|
if ( it != enumFromStringMap.Filter.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SamplerAddressMode> SamplerAddressMode_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerAddressMode.find( value );
|
|
if ( it != enumFromStringMap.SamplerAddressMode.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SamplerCreateFlagBits> SamplerCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SamplerCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SamplerMipmapMode> SamplerMipmapMode_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerMipmapMode.find( value );
|
|
if ( it != enumFromStringMap.SamplerMipmapMode.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DescriptorPoolCreateFlagBits> DescriptorPoolCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorPoolCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.DescriptorPoolCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DescriptorSetLayoutCreateFlagBits> DescriptorSetLayoutCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorSetLayoutCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.DescriptorSetLayoutCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DescriptorType> DescriptorType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorType.find( value );
|
|
if ( it != enumFromStringMap.DescriptorType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DescriptorPoolResetFlagBits> DescriptorPoolResetFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccessFlagBits> AccessFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccessFlagBits.find( value );
|
|
if ( it != enumFromStringMap.AccessFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AttachmentDescriptionFlagBits> AttachmentDescriptionFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AttachmentDescriptionFlagBits.find( value );
|
|
if ( it != enumFromStringMap.AttachmentDescriptionFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AttachmentLoadOp> AttachmentLoadOp_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AttachmentLoadOp.find( value );
|
|
if ( it != enumFromStringMap.AttachmentLoadOp.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AttachmentStoreOp> AttachmentStoreOp_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AttachmentStoreOp.find( value );
|
|
if ( it != enumFromStringMap.AttachmentStoreOp.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DependencyFlagBits> DependencyFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DependencyFlagBits.find( value );
|
|
if ( it != enumFromStringMap.DependencyFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<FramebufferCreateFlagBits> FramebufferCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FramebufferCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.FramebufferCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineBindPoint> PipelineBindPoint_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineBindPoint.find( value );
|
|
if ( it != enumFromStringMap.PipelineBindPoint.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<RenderPassCreateFlagBits> RenderPassCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RenderPassCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.RenderPassCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SubpassDescriptionFlagBits> SubpassDescriptionFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubpassDescriptionFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SubpassDescriptionFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CommandPoolCreateFlagBits> CommandPoolCreateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandPoolCreateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.CommandPoolCreateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CommandPoolResetFlagBits> CommandPoolResetFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandPoolResetFlagBits.find( value );
|
|
if ( it != enumFromStringMap.CommandPoolResetFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CommandBufferLevel> CommandBufferLevel_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandBufferLevel.find( value );
|
|
if ( it != enumFromStringMap.CommandBufferLevel.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CommandBufferResetFlagBits> CommandBufferResetFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandBufferResetFlagBits.find( value );
|
|
if ( it != enumFromStringMap.CommandBufferResetFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CommandBufferUsageFlagBits> CommandBufferUsageFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CommandBufferUsageFlagBits.find( value );
|
|
if ( it != enumFromStringMap.CommandBufferUsageFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueryControlFlagBits> QueryControlFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryControlFlagBits.find( value );
|
|
if ( it != enumFromStringMap.QueryControlFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<IndexType> IndexType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndexType.find( value );
|
|
if ( it != enumFromStringMap.IndexType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<StencilFaceFlagBits> StencilFaceFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.StencilFaceFlagBits.find( value );
|
|
if ( it != enumFromStringMap.StencilFaceFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SubpassContents> SubpassContents_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubpassContents.find( value );
|
|
if ( it != enumFromStringMap.SubpassContents.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_VERSION_1_1 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<SubgroupFeatureFlagBits> SubgroupFeatureFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubgroupFeatureFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SubgroupFeatureFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PeerMemoryFeatureFlagBits> PeerMemoryFeatureFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PeerMemoryFeatureFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PeerMemoryFeatureFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<MemoryAllocateFlagBits> MemoryAllocateFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryAllocateFlagBits.find( value );
|
|
if ( it != enumFromStringMap.MemoryAllocateFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CommandPoolTrimFlagBits> CommandPoolTrimFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PointClippingBehavior> PointClippingBehavior_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PointClippingBehavior.find( value );
|
|
if ( it != enumFromStringMap.PointClippingBehavior.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<TessellationDomainOrigin> TessellationDomainOrigin_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.TessellationDomainOrigin.find( value );
|
|
if ( it != enumFromStringMap.TessellationDomainOrigin.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SamplerYcbcrModelConversion> SamplerYcbcrModelConversion_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerYcbcrModelConversion.find( value );
|
|
if ( it != enumFromStringMap.SamplerYcbcrModelConversion.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SamplerYcbcrRange> SamplerYcbcrRange_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerYcbcrRange.find( value );
|
|
if ( it != enumFromStringMap.SamplerYcbcrRange.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ChromaLocation> ChromaLocation_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ChromaLocation.find( value );
|
|
if ( it != enumFromStringMap.ChromaLocation.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DescriptorUpdateTemplateType> DescriptorUpdateTemplateType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorUpdateTemplateType.find( value );
|
|
if ( it != enumFromStringMap.DescriptorUpdateTemplateType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DescriptorUpdateTemplateCreateFlagBits> DescriptorUpdateTemplateCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryHandleTypeFlagBits> ExternalMemoryHandleTypeFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryHandleTypeFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryHandleTypeFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryFeatureFlagBits> ExternalMemoryFeatureFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryFeatureFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryFeatureFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalFenceHandleTypeFlagBits> ExternalFenceHandleTypeFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalFenceHandleTypeFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ExternalFenceHandleTypeFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalFenceFeatureFlagBits> ExternalFenceFeatureFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalFenceFeatureFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ExternalFenceFeatureFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<FenceImportFlagBits> FenceImportFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FenceImportFlagBits.find( value );
|
|
if ( it != enumFromStringMap.FenceImportFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreImportFlagBits> SemaphoreImportFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SemaphoreImportFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SemaphoreImportFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalSemaphoreHandleTypeFlagBits> ExternalSemaphoreHandleTypeFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalSemaphoreHandleTypeFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ExternalSemaphoreHandleTypeFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalSemaphoreFeatureFlagBits> ExternalSemaphoreFeatureFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalSemaphoreFeatureFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ExternalSemaphoreFeatureFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_VERSION_1_2 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DriverId> DriverId_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DriverId.find( value );
|
|
if ( it != enumFromStringMap.DriverId.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderFloatControlsIndependence> ShaderFloatControlsIndependence_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderFloatControlsIndependence.find( value );
|
|
if ( it != enumFromStringMap.ShaderFloatControlsIndependence.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DescriptorBindingFlagBits> DescriptorBindingFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DescriptorBindingFlagBits.find( value );
|
|
if ( it != enumFromStringMap.DescriptorBindingFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ResolveModeFlagBits> ResolveModeFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ResolveModeFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ResolveModeFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SamplerReductionMode> SamplerReductionMode_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SamplerReductionMode.find( value );
|
|
if ( it != enumFromStringMap.SamplerReductionMode.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreType> SemaphoreType_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SemaphoreType.find( value );
|
|
if ( it != enumFromStringMap.SemaphoreType.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SemaphoreWaitFlagBits> SemaphoreWaitFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SemaphoreWaitFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SemaphoreWaitFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_VERSION_1_3 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCreationFeedbackFlagBits> PipelineCreationFeedbackFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCreationFeedbackFlagBits.find( value );
|
|
if ( it != enumFromStringMap.PipelineCreationFeedbackFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ToolPurposeFlagBits> ToolPurposeFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ToolPurposeFlagBits.find( value );
|
|
if ( it != enumFromStringMap.ToolPurposeFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PrivateDataSlotCreateFlagBits> PrivateDataSlotCreateFlagBits_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineStageFlagBits2> PipelineStageFlagBits2_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineStageFlagBits2.find( value );
|
|
if ( it != enumFromStringMap.PipelineStageFlagBits2.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccessFlagBits2> AccessFlagBits2_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccessFlagBits2.find( value );
|
|
if ( it != enumFromStringMap.AccessFlagBits2.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<SubmitFlagBits> SubmitFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubmitFlagBits.find( value );
|
|
if ( it != enumFromStringMap.SubmitFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<RenderingFlagBits> RenderingFlagBits_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RenderingFlagBits.find( value );
|
|
if ( it != enumFromStringMap.RenderingFlagBits.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<FormatFeatureFlagBits2> FormatFeatureFlagBits2_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FormatFeatureFlagBits2.find( value );
|
|
if ( it != enumFromStringMap.FormatFeatureFlagBits2.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<SurfaceTransformFlagBitsKHR> SurfaceTransformFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SurfaceTransformFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.SurfaceTransformFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PresentModeKHR> PresentModeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PresentModeKHR.find( value );
|
|
if ( it != enumFromStringMap.PresentModeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ColorSpaceKHR> ColorSpaceKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ColorSpaceKHR.find( value );
|
|
if ( it != enumFromStringMap.ColorSpaceKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CompositeAlphaFlagBitsKHR> CompositeAlphaFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CompositeAlphaFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.CompositeAlphaFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_swapchain ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<SwapchainCreateFlagBitsKHR> SwapchainCreateFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SwapchainCreateFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.SwapchainCreateFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceGroupPresentModeFlagBitsKHR> DeviceGroupPresentModeFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceGroupPresentModeFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.DeviceGroupPresentModeFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_display ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DisplayPlaneAlphaFlagBitsKHR> DisplayPlaneAlphaFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplayPlaneAlphaFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.DisplayPlaneAlphaFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DisplayModeCreateFlagBitsKHR> DisplayModeCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DisplaySurfaceCreateFlagBitsKHR> DisplaySurfaceCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
//=== VK_KHR_xlib_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<XlibSurfaceCreateFlagBitsKHR> XlibSurfaceCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
//=== VK_KHR_xcb_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<XcbSurfaceCreateFlagBitsKHR> XcbSurfaceCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
//=== VK_KHR_wayland_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<WaylandSurfaceCreateFlagBitsKHR> WaylandSurfaceCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
//=== VK_KHR_android_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<AndroidSurfaceCreateFlagBitsKHR> AndroidSurfaceCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_KHR_win32_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<Win32SurfaceCreateFlagBitsKHR> Win32SurfaceCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
//=== VK_EXT_debug_report ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DebugReportFlagBitsEXT> DebugReportFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugReportFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.DebugReportFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DebugReportObjectTypeEXT> DebugReportObjectTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugReportObjectTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.DebugReportObjectTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_rasterization_order ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<RasterizationOrderAMD> RasterizationOrderAMD_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RasterizationOrderAMD.find( value );
|
|
if ( it != enumFromStringMap.RasterizationOrderAMD.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_video_queue ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoCodecOperationFlagBitsKHR> VideoCodecOperationFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoCodecOperationFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoCodecOperationFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoChromaSubsamplingFlagBitsKHR> VideoChromaSubsamplingFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoChromaSubsamplingFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoChromaSubsamplingFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoComponentBitDepthFlagBitsKHR> VideoComponentBitDepthFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoComponentBitDepthFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoComponentBitDepthFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoCapabilityFlagBitsKHR> VideoCapabilityFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoCapabilityFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoCapabilityFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoSessionCreateFlagBitsKHR> VideoSessionCreateFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoSessionCreateFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoSessionCreateFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoCodingControlFlagBitsKHR> VideoCodingControlFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoCodingControlFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoCodingControlFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueryResultStatusKHR> QueryResultStatusKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryResultStatusKHR.find( value );
|
|
if ( it != enumFromStringMap.QueryResultStatusKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoSessionParametersCreateFlagBitsKHR> VideoSessionParametersCreateFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoBeginCodingFlagBitsKHR> VideoBeginCodingFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEndCodingFlagBitsKHR> VideoEndCodingFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_KHR_video_decode_queue ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeCapabilityFlagBitsKHR> VideoDecodeCapabilityFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoDecodeCapabilityFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoDecodeCapabilityFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeUsageFlagBitsKHR> VideoDecodeUsageFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoDecodeUsageFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoDecodeUsageFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeFlagBitsKHR> VideoDecodeFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_transform_feedback ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationStateStreamCreateFlagBitsEXT>
|
|
PipelineRasterizationStateStreamCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_EXT_video_encode_h264 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH264CapabilityFlagBitsEXT> VideoEncodeH264CapabilityFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH264CapabilityFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH264CapabilityFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH264StdFlagBitsEXT> VideoEncodeH264StdFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH264StdFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH264StdFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH264RateControlFlagBitsEXT> VideoEncodeH264RateControlFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH264RateControlFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH264RateControlFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_EXT_video_encode_h265 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265CapabilityFlagBitsEXT> VideoEncodeH265CapabilityFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265CapabilityFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265CapabilityFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265StdFlagBitsEXT> VideoEncodeH265StdFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265StdFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265StdFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265CtbSizeFlagBitsEXT> VideoEncodeH265CtbSizeFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265CtbSizeFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265CtbSizeFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265TransformBlockSizeFlagBitsEXT>
|
|
VideoEncodeH265TransformBlockSizeFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265TransformBlockSizeFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265TransformBlockSizeFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeH265RateControlFlagBitsEXT> VideoEncodeH265RateControlFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeH265RateControlFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeH265RateControlFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_KHR_video_decode_h264 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoDecodeH264PictureLayoutFlagBitsKHR> VideoDecodeH264PictureLayoutFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoDecodeH264PictureLayoutFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoDecodeH264PictureLayoutFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_shader_info ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderInfoTypeAMD> ShaderInfoTypeAMD_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderInfoTypeAMD.find( value );
|
|
if ( it != enumFromStringMap.ShaderInfoTypeAMD.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_GGP )
|
|
//=== VK_GGP_stream_descriptor_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<StreamDescriptorSurfaceCreateFlagBitsGGP> StreamDescriptorSurfaceCreateFlagBitsGGP_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_GGP*/
|
|
|
|
//=== VK_NV_external_memory_capabilities ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryHandleTypeFlagBitsNV> ExternalMemoryHandleTypeFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryHandleTypeFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryHandleTypeFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExternalMemoryFeatureFlagBitsNV> ExternalMemoryFeatureFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExternalMemoryFeatureFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.ExternalMemoryFeatureFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_validation_flags ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ValidationCheckEXT> ValidationCheckEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationCheckEXT.find( value );
|
|
if ( it != enumFromStringMap.ValidationCheckEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_VI_NN )
|
|
//=== VK_NN_vi_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ViSurfaceCreateFlagBitsNN> ViSurfaceCreateFlagBitsNN_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
|
//=== VK_EXT_pipeline_robustness ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineRobustnessBufferBehaviorEXT> PipelineRobustnessBufferBehaviorEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineRobustnessBufferBehaviorEXT.find( value );
|
|
if ( it != enumFromStringMap.PipelineRobustnessBufferBehaviorEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineRobustnessImageBehaviorEXT> PipelineRobustnessImageBehaviorEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineRobustnessImageBehaviorEXT.find( value );
|
|
if ( it != enumFromStringMap.PipelineRobustnessImageBehaviorEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_conditional_rendering ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ConditionalRenderingFlagBitsEXT> ConditionalRenderingFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ConditionalRenderingFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.ConditionalRenderingFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_display_surface_counter ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<SurfaceCounterFlagBitsEXT> SurfaceCounterFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SurfaceCounterFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.SurfaceCounterFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_display_control ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DisplayPowerStateEXT> DisplayPowerStateEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplayPowerStateEXT.find( value );
|
|
if ( it != enumFromStringMap.DisplayPowerStateEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceEventTypeEXT> DeviceEventTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceEventTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.DeviceEventTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DisplayEventTypeEXT> DisplayEventTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplayEventTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.DisplayEventTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_viewport_swizzle ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ViewportCoordinateSwizzleNV> ViewportCoordinateSwizzleNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ViewportCoordinateSwizzleNV.find( value );
|
|
if ( it != enumFromStringMap.ViewportCoordinateSwizzleNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineViewportSwizzleStateCreateFlagBitsNV> PipelineViewportSwizzleStateCreateFlagBitsNV_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_discard_rectangles ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DiscardRectangleModeEXT> DiscardRectangleModeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DiscardRectangleModeEXT.find( value );
|
|
if ( it != enumFromStringMap.DiscardRectangleModeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineDiscardRectangleStateCreateFlagBitsEXT>
|
|
PipelineDiscardRectangleStateCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_conservative_rasterization ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ConservativeRasterizationModeEXT> ConservativeRasterizationModeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ConservativeRasterizationModeEXT.find( value );
|
|
if ( it != enumFromStringMap.ConservativeRasterizationModeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationConservativeStateCreateFlagBitsEXT>
|
|
PipelineRasterizationConservativeStateCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_depth_clip_enable ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineRasterizationDepthClipStateCreateFlagBitsEXT>
|
|
PipelineRasterizationDepthClipStateCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_KHR_performance_query ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterDescriptionFlagBitsKHR> PerformanceCounterDescriptionFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterDescriptionFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterDescriptionFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterScopeKHR> PerformanceCounterScopeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterScopeKHR.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterScopeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterStorageKHR> PerformanceCounterStorageKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterStorageKHR.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterStorageKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceCounterUnitKHR> PerformanceCounterUnitKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceCounterUnitKHR.find( value );
|
|
if ( it != enumFromStringMap.PerformanceCounterUnitKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AcquireProfilingLockFlagBitsKHR> AcquireProfilingLockFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
//=== VK_MVK_ios_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<IOSSurfaceCreateFlagBitsMVK> IOSSurfaceCreateFlagBitsMVK_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
|
#if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
//=== VK_MVK_macos_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<MacOSSurfaceCreateFlagBitsMVK> MacOSSurfaceCreateFlagBitsMVK_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
|
//=== VK_EXT_debug_utils ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessageSeverityFlagBitsEXT> DebugUtilsMessageSeverityFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugUtilsMessageSeverityFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.DebugUtilsMessageSeverityFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessageTypeFlagBitsEXT> DebugUtilsMessageTypeFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DebugUtilsMessageTypeFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.DebugUtilsMessageTypeFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessengerCallbackDataFlagBitsEXT> DebugUtilsMessengerCallbackDataFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DebugUtilsMessengerCreateFlagBitsEXT> DebugUtilsMessengerCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_blend_operation_advanced ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<BlendOverlapEXT> BlendOverlapEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlendOverlapEXT.find( value );
|
|
if ( it != enumFromStringMap.BlendOverlapEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_fragment_coverage_to_color ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCoverageToColorStateCreateFlagBitsNV> PipelineCoverageToColorStateCreateFlagBitsNV_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_KHR_acceleration_structure ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureTypeKHR> AccelerationStructureTypeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureTypeKHR.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureTypeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureBuildTypeKHR> AccelerationStructureBuildTypeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureBuildTypeKHR.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureBuildTypeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<GeometryFlagBitsKHR> GeometryFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GeometryFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.GeometryFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<GeometryInstanceFlagBitsKHR> GeometryInstanceFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GeometryInstanceFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.GeometryInstanceFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BuildAccelerationStructureFlagBitsKHR> BuildAccelerationStructureFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildAccelerationStructureFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.BuildAccelerationStructureFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CopyAccelerationStructureModeKHR> CopyAccelerationStructureModeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CopyAccelerationStructureModeKHR.find( value );
|
|
if ( it != enumFromStringMap.CopyAccelerationStructureModeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<GeometryTypeKHR> GeometryTypeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GeometryTypeKHR.find( value );
|
|
if ( it != enumFromStringMap.GeometryTypeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureCompatibilityKHR> AccelerationStructureCompatibilityKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureCompatibilityKHR.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureCompatibilityKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureCreateFlagBitsKHR> AccelerationStructureCreateFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureCreateFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureCreateFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BuildAccelerationStructureModeKHR> BuildAccelerationStructureModeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildAccelerationStructureModeKHR.find( value );
|
|
if ( it != enumFromStringMap.BuildAccelerationStructureModeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_ray_tracing_pipeline ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<RayTracingShaderGroupTypeKHR> RayTracingShaderGroupTypeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RayTracingShaderGroupTypeKHR.find( value );
|
|
if ( it != enumFromStringMap.RayTracingShaderGroupTypeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderGroupShaderKHR> ShaderGroupShaderKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderGroupShaderKHR.find( value );
|
|
if ( it != enumFromStringMap.ShaderGroupShaderKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_framebuffer_mixed_samples ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<CoverageModulationModeNV> CoverageModulationModeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CoverageModulationModeNV.find( value );
|
|
if ( it != enumFromStringMap.CoverageModulationModeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCoverageModulationStateCreateFlagBitsNV>
|
|
PipelineCoverageModulationStateCreateFlagBitsNV_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_validation_cache ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ValidationCacheHeaderVersionEXT> ValidationCacheHeaderVersionEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationCacheHeaderVersionEXT.find( value );
|
|
if ( it != enumFromStringMap.ValidationCacheHeaderVersionEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ValidationCacheCreateFlagBitsEXT> ValidationCacheCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_NV_shading_rate_image ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShadingRatePaletteEntryNV> ShadingRatePaletteEntryNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShadingRatePaletteEntryNV.find( value );
|
|
if ( it != enumFromStringMap.ShadingRatePaletteEntryNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CoarseSampleOrderTypeNV> CoarseSampleOrderTypeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CoarseSampleOrderTypeNV.find( value );
|
|
if ( it != enumFromStringMap.CoarseSampleOrderTypeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_ray_tracing ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMemoryRequirementsTypeNV>
|
|
AccelerationStructureMemoryRequirementsTypeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureMemoryRequirementsTypeNV.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureMemoryRequirementsTypeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_pipeline_compiler_control ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCompilerControlFlagBitsAMD> PipelineCompilerControlFlagBitsAMD_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_calibrated_timestamps ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<TimeDomainEXT> TimeDomainEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.TimeDomainEXT.find( value );
|
|
if ( it != enumFromStringMap.TimeDomainEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_global_priority ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueueGlobalPriorityKHR> QueueGlobalPriorityKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueueGlobalPriorityKHR.find( value );
|
|
if ( it != enumFromStringMap.QueueGlobalPriorityKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_memory_overallocation_behavior ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<MemoryOverallocationBehaviorAMD> MemoryOverallocationBehaviorAMD_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryOverallocationBehaviorAMD.find( value );
|
|
if ( it != enumFromStringMap.MemoryOverallocationBehaviorAMD.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_INTEL_performance_query ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceConfigurationTypeINTEL> PerformanceConfigurationTypeINTEL_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceConfigurationTypeINTEL.find( value );
|
|
if ( it != enumFromStringMap.PerformanceConfigurationTypeINTEL.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<QueryPoolSamplingModeINTEL> QueryPoolSamplingModeINTEL_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.QueryPoolSamplingModeINTEL.find( value );
|
|
if ( it != enumFromStringMap.QueryPoolSamplingModeINTEL.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceOverrideTypeINTEL> PerformanceOverrideTypeINTEL_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceOverrideTypeINTEL.find( value );
|
|
if ( it != enumFromStringMap.PerformanceOverrideTypeINTEL.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceParameterTypeINTEL> PerformanceParameterTypeINTEL_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceParameterTypeINTEL.find( value );
|
|
if ( it != enumFromStringMap.PerformanceParameterTypeINTEL.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PerformanceValueTypeINTEL> PerformanceValueTypeINTEL_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PerformanceValueTypeINTEL.find( value );
|
|
if ( it != enumFromStringMap.PerformanceValueTypeINTEL.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImagePipeSurfaceCreateFlagBitsFUCHSIA> ImagePipeSurfaceCreateFlagBitsFUCHSIA_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
//=== VK_EXT_metal_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<MetalSurfaceCreateFlagBitsEXT> MetalSurfaceCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
|
//=== VK_KHR_fragment_shading_rate ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<FragmentShadingRateCombinerOpKHR> FragmentShadingRateCombinerOpKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FragmentShadingRateCombinerOpKHR.find( value );
|
|
if ( it != enumFromStringMap.FragmentShadingRateCombinerOpKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_AMD_shader_core_properties2 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderCorePropertiesFlagBitsAMD> ShaderCorePropertiesFlagBitsAMD_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_validation_features ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ValidationFeatureEnableEXT> ValidationFeatureEnableEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationFeatureEnableEXT.find( value );
|
|
if ( it != enumFromStringMap.ValidationFeatureEnableEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ValidationFeatureDisableEXT> ValidationFeatureDisableEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ValidationFeatureDisableEXT.find( value );
|
|
if ( it != enumFromStringMap.ValidationFeatureDisableEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_coverage_reduction_mode ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<CoverageReductionModeNV> CoverageReductionModeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CoverageReductionModeNV.find( value );
|
|
if ( it != enumFromStringMap.CoverageReductionModeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCoverageReductionStateCreateFlagBitsNV>
|
|
PipelineCoverageReductionStateCreateFlagBitsNV_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_provoking_vertex ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ProvokingVertexModeEXT> ProvokingVertexModeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ProvokingVertexModeEXT.find( value );
|
|
if ( it != enumFromStringMap.ProvokingVertexModeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_EXT_full_screen_exclusive ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<FullScreenExclusiveEXT> FullScreenExclusiveEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FullScreenExclusiveEXT.find( value );
|
|
if ( it != enumFromStringMap.FullScreenExclusiveEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
//=== VK_EXT_headless_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<HeadlessSurfaceCreateFlagBitsEXT> HeadlessSurfaceCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_line_rasterization ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<LineRasterizationModeEXT> LineRasterizationModeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LineRasterizationModeEXT.find( value );
|
|
if ( it != enumFromStringMap.LineRasterizationModeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_pipeline_executable_properties ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineExecutableStatisticFormatKHR> PipelineExecutableStatisticFormatKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineExecutableStatisticFormatKHR.find( value );
|
|
if ( it != enumFromStringMap.PipelineExecutableStatisticFormatKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_host_image_copy ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<HostImageCopyFlagBitsEXT> HostImageCopyFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.HostImageCopyFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.HostImageCopyFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_map_memory2 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<MemoryUnmapFlagBitsKHR> MemoryUnmapFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_surface_maintenance1 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PresentScalingFlagBitsEXT> PresentScalingFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PresentScalingFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.PresentScalingFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<PresentGravityFlagBitsEXT> PresentGravityFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PresentGravityFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.PresentGravityFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_device_generated_commands ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<IndirectStateFlagBitsNV> IndirectStateFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndirectStateFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.IndirectStateFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<IndirectCommandsTokenTypeNV> IndirectCommandsTokenTypeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndirectCommandsTokenTypeNV.find( value );
|
|
if ( it != enumFromStringMap.IndirectCommandsTokenTypeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<IndirectCommandsLayoutUsageFlagBitsNV> IndirectCommandsLayoutUsageFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.IndirectCommandsLayoutUsageFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.IndirectCommandsLayoutUsageFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_depth_bias_control ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DepthBiasRepresentationEXT> DepthBiasRepresentationEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DepthBiasRepresentationEXT.find( value );
|
|
if ( it != enumFromStringMap.DepthBiasRepresentationEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_device_memory_report ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceMemoryReportEventTypeEXT> DeviceMemoryReportEventTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceMemoryReportEventTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.DeviceMemoryReportEventTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceMemoryReportFlagBitsEXT> DeviceMemoryReportFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_KHR_video_encode_queue ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeCapabilityFlagBitsKHR> VideoEncodeCapabilityFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeCapabilityFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeCapabilityFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeFeedbackFlagBitsKHR> VideoEncodeFeedbackFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeFeedbackFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeFeedbackFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeUsageFlagBitsKHR> VideoEncodeUsageFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeUsageFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeUsageFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeContentFlagBitsKHR> VideoEncodeContentFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeContentFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeContentFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeTuningModeKHR> VideoEncodeTuningModeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeTuningModeKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeTuningModeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeRateControlModeFlagBitsKHR> VideoEncodeRateControlModeFlagBitsKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.VideoEncodeRateControlModeFlagBitsKHR.find( value );
|
|
if ( it != enumFromStringMap.VideoEncodeRateControlModeFlagBitsKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeFlagBitsKHR> VideoEncodeFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<VideoEncodeRateControlFlagBitsKHR> VideoEncodeRateControlFlagBitsKHR_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_NV_device_diagnostics_config ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceDiagnosticsConfigFlagBitsNV> DeviceDiagnosticsConfigFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceDiagnosticsConfigFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.DeviceDiagnosticsConfigFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
//=== VK_EXT_metal_objects ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ExportMetalObjectTypeFlagBitsEXT> ExportMetalObjectTypeFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ExportMetalObjectTypeFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.ExportMetalObjectTypeFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
|
//=== VK_EXT_graphics_pipeline_library ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<GraphicsPipelineLibraryFlagBitsEXT> GraphicsPipelineLibraryFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.GraphicsPipelineLibraryFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.GraphicsPipelineLibraryFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_fragment_shading_rate_enums ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<FragmentShadingRateNV> FragmentShadingRateNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FragmentShadingRateNV.find( value );
|
|
if ( it != enumFromStringMap.FragmentShadingRateNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<FragmentShadingRateTypeNV> FragmentShadingRateTypeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FragmentShadingRateTypeNV.find( value );
|
|
if ( it != enumFromStringMap.FragmentShadingRateTypeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_ray_tracing_motion_blur ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMotionInstanceTypeNV> AccelerationStructureMotionInstanceTypeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.AccelerationStructureMotionInstanceTypeNV.find( value );
|
|
if ( it != enumFromStringMap.AccelerationStructureMotionInstanceTypeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMotionInfoFlagBitsNV> AccelerationStructureMotionInfoFlagBitsNV_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<AccelerationStructureMotionInstanceFlagBitsNV>
|
|
AccelerationStructureMotionInstanceFlagBitsNV_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_EXT_image_compression_control ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageCompressionFlagBitsEXT> ImageCompressionFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageCompressionFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.ImageCompressionFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageCompressionFixedRateFlagBitsEXT> ImageCompressionFixedRateFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageCompressionFixedRateFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.ImageCompressionFixedRateFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_device_fault ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceFaultAddressTypeEXT> DeviceFaultAddressTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceFaultAddressTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.DeviceFaultAddressTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceFaultVendorBinaryHeaderVersionEXT> DeviceFaultVendorBinaryHeaderVersionEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceFaultVendorBinaryHeaderVersionEXT.find( value );
|
|
if ( it != enumFromStringMap.DeviceFaultVendorBinaryHeaderVersionEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
//=== VK_EXT_directfb_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DirectFBSurfaceCreateFlagBitsEXT> DirectFBSurfaceCreateFlagBitsEXT_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
|
//=== VK_EXT_device_address_binding_report ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceAddressBindingFlagBitsEXT> DeviceAddressBindingFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceAddressBindingFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.DeviceAddressBindingFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DeviceAddressBindingTypeEXT> DeviceAddressBindingTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DeviceAddressBindingTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.DeviceAddressBindingTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_buffer_collection ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageConstraintsInfoFlagBitsFUCHSIA> ImageConstraintsInfoFlagBitsFUCHSIA_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ImageConstraintsInfoFlagBitsFUCHSIA.find( value );
|
|
if ( it != enumFromStringMap.ImageConstraintsInfoFlagBitsFUCHSIA.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ImageFormatConstraintsFlagBitsFUCHSIA> ImageFormatConstraintsFlagBitsFUCHSIA_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
//=== VK_EXT_frame_boundary ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<FrameBoundaryFlagBitsEXT> FrameBoundaryFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.FrameBoundaryFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.FrameBoundaryFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
//=== VK_QNX_screen_surface ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ScreenSurfaceCreateFlagBitsQNX> ScreenSurfaceCreateFlagBitsQNX_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
|
//=== VK_EXT_opacity_micromap ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<MicromapTypeEXT> MicromapTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MicromapTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.MicromapTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BuildMicromapFlagBitsEXT> BuildMicromapFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildMicromapFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.BuildMicromapFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<CopyMicromapModeEXT> CopyMicromapModeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CopyMicromapModeEXT.find( value );
|
|
if ( it != enumFromStringMap.CopyMicromapModeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<MicromapCreateFlagBitsEXT> MicromapCreateFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MicromapCreateFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.MicromapCreateFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BuildMicromapModeEXT> BuildMicromapModeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BuildMicromapModeEXT.find( value );
|
|
if ( it != enumFromStringMap.BuildMicromapModeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpacityMicromapFormatEXT> OpacityMicromapFormatEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpacityMicromapFormatEXT.find( value );
|
|
if ( it != enumFromStringMap.OpacityMicromapFormatEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpacityMicromapSpecialIndexEXT> OpacityMicromapSpecialIndexEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpacityMicromapSpecialIndexEXT.find( value );
|
|
if ( it != enumFromStringMap.OpacityMicromapSpecialIndexEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
//=== VK_NV_displacement_micromap ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DisplacementMicromapFormatNV> DisplacementMicromapFormatNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DisplacementMicromapFormatNV.find( value );
|
|
if ( it != enumFromStringMap.DisplacementMicromapFormatNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
|
//=== VK_ARM_scheduling_controls ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PhysicalDeviceSchedulingControlsFlagBitsARM>
|
|
PhysicalDeviceSchedulingControlsFlagBitsARM_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PhysicalDeviceSchedulingControlsFlagBitsARM.find( value );
|
|
if ( it != enumFromStringMap.PhysicalDeviceSchedulingControlsFlagBitsARM.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_memory_decompression ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<MemoryDecompressionMethodFlagBitsNV> MemoryDecompressionMethodFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.MemoryDecompressionMethodFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.MemoryDecompressionMethodFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_subpass_merge_feedback ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<SubpassMergeStatusEXT> SubpassMergeStatusEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.SubpassMergeStatusEXT.find( value );
|
|
if ( it != enumFromStringMap.SubpassMergeStatusEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_LUNARG_direct_driver_loading ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<DirectDriverLoadingModeLUNARG> DirectDriverLoadingModeLUNARG_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.DirectDriverLoadingModeLUNARG.find( value );
|
|
if ( it != enumFromStringMap.DirectDriverLoadingModeLUNARG.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<DirectDriverLoadingFlagBitsLUNARG> DirectDriverLoadingFlagBitsLUNARG_from_string( const std::string & )
|
|
{
|
|
return "std::nullopt";
|
|
}
|
|
|
|
//=== VK_NV_optical_flow ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowUsageFlagBitsNV> OpticalFlowUsageFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowUsageFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowUsageFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowGridSizeFlagBitsNV> OpticalFlowGridSizeFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowGridSizeFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowGridSizeFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowPerformanceLevelNV> OpticalFlowPerformanceLevelNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowPerformanceLevelNV.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowPerformanceLevelNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowSessionBindingPointNV> OpticalFlowSessionBindingPointNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowSessionBindingPointNV.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowSessionBindingPointNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowSessionCreateFlagBitsNV> OpticalFlowSessionCreateFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowSessionCreateFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowSessionCreateFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OpticalFlowExecuteFlagBitsNV> OpticalFlowExecuteFlagBitsNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OpticalFlowExecuteFlagBitsNV.find( value );
|
|
if ( it != enumFromStringMap.OpticalFlowExecuteFlagBitsNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_maintenance5 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<PipelineCreateFlagBits2KHR> PipelineCreateFlagBits2KHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.PipelineCreateFlagBits2KHR.find( value );
|
|
if ( it != enumFromStringMap.PipelineCreateFlagBits2KHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<BufferUsageFlagBits2KHR> BufferUsageFlagBits2KHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BufferUsageFlagBits2KHR.find( value );
|
|
if ( it != enumFromStringMap.BufferUsageFlagBits2KHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_EXT_shader_object ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderCreateFlagBitsEXT> ShaderCreateFlagBitsEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderCreateFlagBitsEXT.find( value );
|
|
if ( it != enumFromStringMap.ShaderCreateFlagBitsEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ShaderCodeTypeEXT> ShaderCodeTypeEXT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ShaderCodeTypeEXT.find( value );
|
|
if ( it != enumFromStringMap.ShaderCodeTypeEXT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_ray_tracing_invocation_reorder ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<RayTracingInvocationReorderModeNV> RayTracingInvocationReorderModeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.RayTracingInvocationReorderModeNV.find( value );
|
|
if ( it != enumFromStringMap.RayTracingInvocationReorderModeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_NV_low_latency2 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<LatencyMarkerNV> LatencyMarkerNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LatencyMarkerNV.find( value );
|
|
if ( it != enumFromStringMap.LatencyMarkerNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<OutOfBandQueueTypeNV> OutOfBandQueueTypeNV_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.OutOfBandQueueTypeNV.find( value );
|
|
if ( it != enumFromStringMap.OutOfBandQueueTypeNV.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_KHR_cooperative_matrix ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<ScopeKHR> ScopeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ScopeKHR.find( value );
|
|
if ( it != enumFromStringMap.ScopeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
VULKAN_HPP_INLINE std::optional<ComponentTypeKHR> ComponentTypeKHR_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.ComponentTypeKHR.find( value );
|
|
if ( it != enumFromStringMap.ComponentTypeKHR.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_QCOM_image_processing2 ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<BlockMatchWindowCompareModeQCOM> BlockMatchWindowCompareModeQCOM_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.BlockMatchWindowCompareModeQCOM.find( value );
|
|
if ( it != enumFromStringMap.BlockMatchWindowCompareModeQCOM.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_QCOM_filter_cubic_weights ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<CubicFilterWeightsQCOM> CubicFilterWeightsQCOM_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.CubicFilterWeightsQCOM.find( value );
|
|
if ( it != enumFromStringMap.CubicFilterWeightsQCOM.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
//=== VK_MSFT_layered_driver ===
|
|
|
|
VULKAN_HPP_INLINE std::optional<LayeredDriverUnderlyingApiMSFT> LayeredDriverUnderlyingApiMSFT_from_string( const std::string & value )
|
|
{
|
|
auto it = enumFromStringMap.LayeredDriverUnderlyingApiMSFT.find( value );
|
|
if ( it != enumFromStringMap.LayeredDriverUnderlyingApiMSFT.end() )
|
|
{
|
|
return it->second;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
} // namespace VULKAN_HPP_NAMESPACE
|
|
#endif
|