diff --git a/WickedEngine/Utility/CMakeLists.txt b/WickedEngine/Utility/CMakeLists.txt
index 7fd7a4dbf..a28f1fcbb 100644
--- a/WickedEngine/Utility/CMakeLists.txt
+++ b/WickedEngine/Utility/CMakeLists.txt
@@ -72,7 +72,6 @@ install(FILES ${HEADER_FILES_spirv}
 
 set(HEADER_FILES_vulkan
 		${CMAKE_CURRENT_SOURCE_DIR}/vulkan/vk_layer.h
-		${CMAKE_CURRENT_SOURCE_DIR}/vulkan/vk_sdk_platform.h
 		${CMAKE_CURRENT_SOURCE_DIR}/vulkan/vulkan_directfb.h
 		${CMAKE_CURRENT_SOURCE_DIR}/vulkan/vulkan_ggp.h
 		${CMAKE_CURRENT_SOURCE_DIR}/vulkan/vulkan_ios.h
diff --git a/WickedEngine/Utility/dx12/d3d12.h b/WickedEngine/Utility/dx12/d3d12.h
index 4941356e6..684ef13d7 100644
--- a/WickedEngine/Utility/dx12/d3d12.h
+++ b/WickedEngine/Utility/dx12/d3d12.h
@@ -1102,7 +1102,7 @@ extern "C"{
 
 #define	D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT	( 15 )
 
-#define	D3D12_PREVIEW_SDK_VERSION	( 713 )
+#define	D3D12_PREVIEW_SDK_VERSION	( 714 )
 
 #define	D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT	( 16 )
 
@@ -1235,7 +1235,7 @@ extern "C"{
 
 #define	D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT	( 2 )
 
-#define	D3D12_SDK_VERSION	( 613 )
+#define	D3D12_SDK_VERSION	( 614 )
 
 #define	D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES	( 32 )
 
@@ -1425,7 +1425,7 @@ enum D3D12_COMMAND_QUEUE_FLAGS
         D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT	= 0x1
     } 	D3D12_COMMAND_QUEUE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_QUEUE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_QUEUE_FLAGS )
 typedef 
 enum D3D12_COMMAND_QUEUE_PRIORITY
     {
@@ -2185,7 +2185,7 @@ enum D3D12_PIPELINE_STATE_FLAGS
         D3D12_PIPELINE_STATE_FLAG_DYNAMIC_INDEX_BUFFER_STRIP_CUT	= 0x8
     } 	D3D12_PIPELINE_STATE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_PIPELINE_STATE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_PIPELINE_STATE_FLAGS )
 typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC
     {
     ID3D12RootSignature *pRootSignature;
@@ -2322,7 +2322,7 @@ enum D3D12_SHADER_MIN_PRECISION_SUPPORT
         D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT	= 0x2
     } 	D3D12_SHADER_MIN_PRECISION_SUPPORT;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_MIN_PRECISION_SUPPORT );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_MIN_PRECISION_SUPPORT )
 typedef 
 enum D3D12_TILED_RESOURCES_TIER
     {
@@ -2385,7 +2385,7 @@ enum D3D12_FORMAT_SUPPORT1
         D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER	= 0x40000000
     } 	D3D12_FORMAT_SUPPORT1;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT1 );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT1 )
 typedef 
 enum D3D12_FORMAT_SUPPORT2
     {
@@ -2404,7 +2404,7 @@ enum D3D12_FORMAT_SUPPORT2
         D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK	= 0x8000
     } 	D3D12_FORMAT_SUPPORT2;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT2 );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT2 )
 typedef 
 enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS
     {
@@ -2412,7 +2412,7 @@ enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS
         D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE	= 0x1
     } 	D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS )
 typedef 
 enum D3D12_CROSS_NODE_SHARING_TIER
     {
@@ -2590,7 +2590,7 @@ enum D3D12_SHADER_CACHE_SUPPORT_FLAGS
         D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE	= 0x40
     } 	D3D12_SHADER_CACHE_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_SUPPORT_FLAGS )
 typedef struct D3D12_FEATURE_DATA_SHADER_CACHE
     {
     _Out_  D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags;
@@ -2616,7 +2616,7 @@ enum D3D12_COMMAND_LIST_SUPPORT_FLAGS
         D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE	= ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE ) 
     } 	D3D12_COMMAND_LIST_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_SUPPORT_FLAGS )
 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3
     {
     _Out_  BOOL CopyQueueTimestampQueriesSupported;
@@ -2953,7 +2953,7 @@ enum D3D12_HEAP_FLAGS
         D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES	= 0x84
     } 	D3D12_HEAP_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_HEAP_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_HEAP_FLAGS )
 typedef struct D3D12_HEAP_DESC
     {
     UINT64 SizeInBytes;
@@ -3004,7 +3004,7 @@ enum D3D12_RESOURCE_FLAGS
         D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE	= 0x100
     } 	D3D12_RESOURCE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_FLAGS )
 typedef struct D3D12_MIP_REGION
     {
     UINT Width;
@@ -3138,7 +3138,7 @@ enum D3D12_TILE_MAPPING_FLAGS
         D3D12_TILE_MAPPING_FLAG_NO_HAZARD	= 0x1
     } 	D3D12_TILE_MAPPING_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_MAPPING_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_MAPPING_FLAGS )
 typedef 
 enum D3D12_TILE_COPY_FLAGS
     {
@@ -3148,7 +3148,7 @@ enum D3D12_TILE_COPY_FLAGS
         D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER	= 0x4
     } 	D3D12_TILE_COPY_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_COPY_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_COPY_FLAGS )
 typedef 
 enum D3D12_RESOURCE_STATES
     {
@@ -3186,7 +3186,7 @@ enum D3D12_RESOURCE_STATES
         D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE	= 0x800000
     } 	D3D12_RESOURCE_STATES;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_STATES );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_STATES )
 typedef 
 enum D3D12_RESOURCE_BARRIER_TYPE
     {
@@ -3223,7 +3223,7 @@ enum D3D12_RESOURCE_BARRIER_FLAGS
         D3D12_RESOURCE_BARRIER_FLAG_END_ONLY	= 0x2
     } 	D3D12_RESOURCE_BARRIER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_BARRIER_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_BARRIER_FLAGS )
 typedef struct D3D12_RESOURCE_BARRIER
     {
     D3D12_RESOURCE_BARRIER_TYPE Type;
@@ -3299,7 +3299,7 @@ enum D3D12_VIEW_INSTANCING_FLAGS
         D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING	= 0x1
     } 	D3D12_VIEW_INSTANCING_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIEW_INSTANCING_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIEW_INSTANCING_FLAGS )
 typedef struct D3D12_VIEW_INSTANCING_DESC
     {
     UINT ViewInstanceCount;
@@ -3335,7 +3335,7 @@ enum D3D12_BUFFER_SRV_FLAGS
         D3D12_BUFFER_SRV_FLAG_RAW	= 0x1
     } 	D3D12_BUFFER_SRV_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_SRV_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_SRV_FLAGS )
 typedef struct D3D12_BUFFER_SRV
     {
     UINT64 FirstElement;
@@ -3606,7 +3606,7 @@ enum D3D12_SAMPLER_FLAGS
         D3D12_SAMPLER_FLAG_NON_NORMALIZED_COORDINATES	= 0x2
     } 	D3D12_SAMPLER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_SAMPLER_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SAMPLER_FLAGS )
 typedef struct D3D12_SAMPLER_DESC2
     {
     D3D12_FILTER Filter;
@@ -3633,7 +3633,7 @@ enum D3D12_BUFFER_UAV_FLAGS
         D3D12_BUFFER_UAV_FLAG_RAW	= 0x1
     } 	D3D12_BUFFER_UAV_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_UAV_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_UAV_FLAGS )
 typedef struct D3D12_BUFFER_UAV
     {
     UINT64 FirstElement;
@@ -3842,7 +3842,7 @@ enum D3D12_DSV_FLAGS
         D3D12_DSV_FLAG_READ_ONLY_STENCIL	= 0x2
     } 	D3D12_DSV_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_DSV_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DSV_FLAGS )
 typedef 
 enum D3D12_DSV_DIMENSION
     {
@@ -3878,7 +3878,7 @@ enum D3D12_CLEAR_FLAGS
         D3D12_CLEAR_FLAG_STENCIL	= 0x2
     } 	D3D12_CLEAR_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_CLEAR_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_CLEAR_FLAGS )
 typedef 
 enum D3D12_FENCE_FLAGS
     {
@@ -3888,7 +3888,7 @@ enum D3D12_FENCE_FLAGS
         D3D12_FENCE_FLAG_NON_MONITORED	= 0x4
     } 	D3D12_FENCE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_FENCE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_FENCE_FLAGS )
 typedef 
 enum D3D12_DESCRIPTOR_HEAP_TYPE
     {
@@ -3906,7 +3906,7 @@ enum D3D12_DESCRIPTOR_HEAP_FLAGS
         D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE	= 0x1
     } 	D3D12_DESCRIPTOR_HEAP_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_HEAP_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_HEAP_FLAGS )
 typedef struct D3D12_DESCRIPTOR_HEAP_DESC
     {
     D3D12_DESCRIPTOR_HEAP_TYPE Type;
@@ -4005,7 +4005,7 @@ enum D3D12_ROOT_SIGNATURE_FLAGS
         D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED	= 0x800
     } 	D3D12_ROOT_SIGNATURE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_SIGNATURE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_SIGNATURE_FLAGS )
 typedef 
 enum D3D12_STATIC_BORDER_COLOR
     {
@@ -4071,7 +4071,7 @@ enum D3D12_DESCRIPTOR_RANGE_FLAGS
         D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS	= 0x10000
     } 	D3D12_DESCRIPTOR_RANGE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_RANGE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_RANGE_FLAGS )
 typedef struct D3D12_DESCRIPTOR_RANGE1
     {
     D3D12_DESCRIPTOR_RANGE_TYPE RangeType;
@@ -4097,7 +4097,7 @@ enum D3D12_ROOT_DESCRIPTOR_FLAGS
         D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC	= 0x8
     } 	D3D12_ROOT_DESCRIPTOR_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_DESCRIPTOR_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_DESCRIPTOR_FLAGS )
 typedef struct D3D12_ROOT_DESCRIPTOR1
     {
     UINT ShaderRegister;
@@ -10067,7 +10067,7 @@ enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS
         D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL	= 0
     } 	D3D12_MULTIPLE_FENCE_WAIT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTIPLE_FENCE_WAIT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTIPLE_FENCE_WAIT_FLAGS )
 typedef 
 enum D3D12_RESIDENCY_PRIORITY
     {
@@ -11277,7 +11277,7 @@ enum D3D12_RESIDENCY_FLAGS
         D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET	= 0x1
     } 	D3D12_RESIDENCY_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESIDENCY_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESIDENCY_FLAGS )
 
 
 extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_c_ifspec;
@@ -11928,21 +11928,21 @@ enum D3D12_COMMAND_LIST_FLAGS
         D3D12_COMMAND_LIST_FLAG_NONE	= 0
     } 	D3D12_COMMAND_LIST_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_FLAGS )
 typedef 
 enum D3D12_COMMAND_POOL_FLAGS
     {
         D3D12_COMMAND_POOL_FLAG_NONE	= 0
     } 	D3D12_COMMAND_POOL_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_POOL_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_POOL_FLAGS )
 typedef 
 enum D3D12_COMMAND_RECORDER_FLAGS
     {
         D3D12_COMMAND_RECORDER_FLAG_NONE	= 0
     } 	D3D12_COMMAND_RECORDER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_RECORDER_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_RECORDER_FLAGS )
 typedef 
 enum D3D12_PROTECTED_SESSION_STATUS
     {
@@ -12107,7 +12107,7 @@ enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS
         D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED	= 0x1
     } 	D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS )
 typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT
     {
     UINT NodeIndex;
@@ -12120,7 +12120,7 @@ enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS
         D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE	= 0
     } 	D3D12_PROTECTED_RESOURCE_SESSION_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_FLAGS )
 typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC
     {
     UINT NodeMask;
@@ -13444,7 +13444,7 @@ enum D3D12_META_COMMAND_PARAMETER_FLAGS
         D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT	= 0x2
     } 	D3D12_META_COMMAND_PARAMETER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_META_COMMAND_PARAMETER_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_META_COMMAND_PARAMETER_FLAGS )
 typedef 
 enum D3D12_META_COMMAND_PARAMETER_STAGE
     {
@@ -13485,7 +13485,7 @@ enum D3D12_GRAPHICS_STATES
         D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK	= ( 1 << 16 ) 
     } 	D3D12_GRAPHICS_STATES;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_GRAPHICS_STATES );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_GRAPHICS_STATES )
 typedef struct D3D12_META_COMMAND_DESC
     {
     GUID Id;
@@ -14229,7 +14229,7 @@ enum D3D12_STATE_OBJECT_FLAGS
         D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS	= 0x4
     } 	D3D12_STATE_OBJECT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS )
 typedef struct D3D12_STATE_OBJECT_CONFIG
     {
     D3D12_STATE_OBJECT_FLAGS Flags;
@@ -14276,7 +14276,7 @@ enum D3D12_EXPORT_FLAGS
         D3D12_EXPORT_FLAG_NONE	= 0
     } 	D3D12_EXPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS )
 typedef struct D3D12_EXPORT_DESC
     {
     LPCWSTR Name;
@@ -14347,7 +14347,7 @@ enum D3D12_RAYTRACING_PIPELINE_FLAGS
         D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES	= 0x200
     } 	D3D12_RAYTRACING_PIPELINE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_PIPELINE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_PIPELINE_FLAGS )
 typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1
     {
     UINT MaxTraceRecursionDepth;
@@ -14450,7 +14450,7 @@ enum D3D12_WORK_GRAPH_FLAGS
         D3D12_WORK_GRAPH_FLAG_INCLUDE_ALL_AVAILABLE_NODES	= 0x1
     } 	D3D12_WORK_GRAPH_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_WORK_GRAPH_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_WORK_GRAPH_FLAGS )
 typedef struct D3D12_WORK_GRAPH_DESC
     {
     LPCWSTR ProgramName;
@@ -14493,7 +14493,7 @@ enum D3D12_RAYTRACING_GEOMETRY_FLAGS
         D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION	= 0x2
     } 	D3D12_RAYTRACING_GEOMETRY_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS )
 typedef 
 enum D3D12_RAYTRACING_GEOMETRY_TYPE
     {
@@ -14511,7 +14511,7 @@ enum D3D12_RAYTRACING_INSTANCE_FLAGS
         D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE	= 0x8
     } 	D3D12_RAYTRACING_INSTANCE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS )
 typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE
     {
     D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
@@ -14570,7 +14570,7 @@ enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS
         D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE	= 0x20
     } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS )
 typedef 
 enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE
     {
@@ -14739,7 +14739,7 @@ enum D3D12_RAY_FLAGS
         D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES	= 0x200
     } 	D3D12_RAY_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAY_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAY_FLAGS )
 typedef 
 enum D3D12_HIT_KIND
     {
@@ -15690,7 +15690,7 @@ enum D3D12_DRED_FLAGS
         D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS	= 2
     } 	D3D12_DRED_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_FLAGS )
 typedef 
 enum D3D12_DRED_ENABLEMENT
     {
@@ -15786,7 +15786,7 @@ enum D3D12_DRED_PAGE_FAULT_FLAGS
         D3D12_DRED_PAGE_FAULT_FLAGS_NONE	= 0
     } 	D3D12_DRED_PAGE_FAULT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_PAGE_FAULT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_PAGE_FAULT_FLAGS )
 typedef 
 enum D3D12_DRED_DEVICE_STATE
     {
@@ -20784,7 +20784,7 @@ enum D3D12_RENDER_PASS_FLAGS
         D3D12_RENDER_PASS_FLAG_BIND_READ_ONLY_STENCIL	= 0x10
     } 	D3D12_RENDER_PASS_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_RENDER_PASS_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RENDER_PASS_FLAGS )
 
 
 extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0051_v0_0_c_ifspec;
@@ -20945,7 +20945,7 @@ enum D3D12_SET_WORK_GRAPH_FLAGS
         D3D12_SET_WORK_GRAPH_FLAG_INITIALIZE	= 0x1
     } 	D3D12_SET_WORK_GRAPH_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_SET_WORK_GRAPH_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SET_WORK_GRAPH_FLAGS )
 typedef struct D3D12_SET_WORK_GRAPH_DESC
     {
     D3D12_PROGRAM_IDENTIFIER ProgramIdentifier;
@@ -20996,7 +20996,7 @@ typedef struct D3D12_NODE_CPU_INPUT
     {
     UINT EntrypointIndex;
     UINT NumRecords;
-    void *pRecords;
+    const void *pRecords;
     UINT64 RecordStrideInBytes;
     } 	D3D12_NODE_CPU_INPUT;
 
@@ -21010,7 +21010,7 @@ typedef struct D3D12_NODE_GPU_INPUT
 typedef struct D3D12_MULTI_NODE_CPU_INPUT
     {
     UINT NumNodeInputs;
-    D3D12_NODE_CPU_INPUT *pNodeInputs;
+    const D3D12_NODE_CPU_INPUT *pNodeInputs;
     UINT64 NodeInputStrideInBytes;
     } 	D3D12_MULTI_NODE_CPU_INPUT;
 
@@ -21902,7 +21902,7 @@ enum D3D12_SHADER_CACHE_FLAGS
         D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR	= 0x2
     } 	D3D12_SHADER_CACHE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_FLAGS )
 typedef struct D3D12_SHADER_CACHE_SESSION_DESC
     {
     GUID Identifier;
@@ -21981,7 +21981,7 @@ enum D3D12_BARRIER_SYNC
         D3D12_BARRIER_SYNC_SPLIT	= 0x80000000
     } 	D3D12_BARRIER_SYNC;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_SYNC );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_SYNC )
 typedef 
 enum D3D12_BARRIER_ACCESS
     {
@@ -22013,7 +22013,7 @@ enum D3D12_BARRIER_ACCESS
         D3D12_BARRIER_ACCESS_NO_ACCESS	= 0x80000000
     } 	D3D12_BARRIER_ACCESS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_ACCESS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_ACCESS )
 typedef 
 enum D3D12_BARRIER_TYPE
     {
@@ -22029,7 +22029,7 @@ enum D3D12_TEXTURE_BARRIER_FLAGS
         D3D12_TEXTURE_BARRIER_FLAG_DISCARD	= 0x1
     } 	D3D12_TEXTURE_BARRIER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_TEXTURE_BARRIER_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_TEXTURE_BARRIER_FLAGS )
 typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE
     {
     UINT IndexOrFirstMipLevel;
@@ -22299,7 +22299,7 @@ enum D3D12_SHADER_CACHE_KIND_FLAGS
         D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED	= 0x8
     } 	D3D12_SHADER_CACHE_KIND_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_KIND_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_KIND_FLAGS )
 typedef 
 enum D3D12_SHADER_CACHE_CONTROL_FLAGS
     {
@@ -22308,7 +22308,7 @@ enum D3D12_SHADER_CACHE_CONTROL_FLAGS
         D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR	= 0x4
     } 	D3D12_SHADER_CACHE_CONTROL_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_CONTROL_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_CONTROL_FLAGS )
 
 
 extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0054_v0_0_c_ifspec;
@@ -28978,7 +28978,7 @@ enum D3D12_DEVICE_FACTORY_FLAGS
         D3D12_DEVICE_FACTORY_FLAG_DISALLOW_STORING_NEW_DEVICE_AS_SINGLETON	= 0x4
     } 	D3D12_DEVICE_FACTORY_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FACTORY_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FACTORY_FLAGS )
 
 
 extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0064_v0_0_c_ifspec;
@@ -29163,7 +29163,7 @@ enum D3D12_DEVICE_FLAGS
         D3D12_DEVICE_FLAG_FORCE_LEGACY_STATE_VALIDATION	= 0x400
     } 	D3D12_DEVICE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FLAGS )
 typedef struct D3D12_DEVICE_CONFIGURATION_DESC
     {
     D3D12_DEVICE_FLAGS Flags;
diff --git a/WickedEngine/Utility/dx12/d3d12compatibility.h b/WickedEngine/Utility/dx12/d3d12compatibility.h
index f61c590c6..bab8d6f11 100644
--- a/WickedEngine/Utility/dx12/d3d12compatibility.h
+++ b/WickedEngine/Utility/dx12/d3d12compatibility.h
@@ -133,7 +133,7 @@ enum D3D12_COMPATIBILITY_SHARED_FLAGS
         D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12	= 0x4
     } 	D3D12_COMPATIBILITY_SHARED_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS )
 typedef 
 enum D3D12_REFLECT_SHARED_PROPERTY
     {
diff --git a/WickedEngine/Utility/dx12/d3d12sdklayers.h b/WickedEngine/Utility/dx12/d3d12sdklayers.h
index 7951a9eec..3bab2e37e 100644
--- a/WickedEngine/Utility/dx12/d3d12sdklayers.h
+++ b/WickedEngine/Utility/dx12/d3d12sdklayers.h
@@ -3314,8 +3314,39 @@ enum D3D12_MESSAGE_ID
         D3D12_MESSAGE_ID_RECREATEAT_INSUFFICIENT_SUPPORT	= 1386,
         D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_STRUCTURED_BUFFER_STRIDE_MISMATCH	= 1387,
         D3D12_MESSAGE_ID_DISPATCH_GRAPH_INVALID	= 1388,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_TARGET_FORMAT_INVALID	= 1389,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_TARGET_DIMENSION_INVALID	= 1390,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_SOURCE_COLOR_FORMAT_INVALID	= 1391,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_SOURCE_DEPTH_FORMAT_INVALID	= 1392,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXPOSURE_SCALE_FORMAT_INVALID	= 1393,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_ENGINE_CREATE_FLAGS_INVALID	= 1394,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_LOAD_FAILURE	= 1395,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_ENGINE_CREATION_ERROR	= 1396,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_UPSCALER_CREATION_ERROR	= 1397,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_UPSCALER_EXECUTION_ERROR	= 1398,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_REGION_INVALID	= 1399,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_TIME_DELTA_INVALID	= 1400,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_REQUIRED_TEXTURE_IS_NULL	= 1401,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_MOTION_VECTORS_FORMAT_INVALID	= 1402,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_FLAGS_INVALID	= 1403,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_FORMAT_INVALID	= 1404,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_EXPOSURE_SCALE_TEXTURE_SIZE_INVALID	= 1405,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_VARIANT_INDEX_OUT_OF_BOUNDS	= 1406,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_VARIANT_ID_NOT_FOUND	= 1407,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_DUPLICATE_VARIANT_ID	= 1408,
+        D3D12_MESSAGE_ID_DIRECTSR_OUT_OF_MEMORY	= 1409,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_UNEXPECTED_TEXTURE_IS_IGNORED	= 1410,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EVICT_UNDERFLOW	= 1411,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_OPTIONAL_TEXTURE_IS_NULL	= 1412,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_INVALID_CAMERA_JITTER	= 1413,
         D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_WARNING	= 1414,
-        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_WARNING + 1 ) 
+        D3D12_MESSAGE_ID_GUID_TEXTURE_LAYOUT_UNSUPPORTED	= 1415,
+        D3D12_MESSAGE_ID_RESOLVE_ENCODER_INPUT_PARAM_LAYOUT_INVALID_PARAMETERS	= 1416,
+        D3D12_MESSAGE_ID_INVALID_BARRIER_ACCESS	= 1417,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INSTANCE_COUNT_ZERO	= 1418,
+        D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SET_BEFORE_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG	= 1419,
+        D3D12_MESSAGE_ID_DIFFERENT_DESCRIPTOR_HEAP_SET_AFTER_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG	= 1420,
+        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_DIFFERENT_DESCRIPTOR_HEAP_SET_AFTER_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG + 1 ) 
     } 	D3D12_MESSAGE_ID;
 
 typedef struct D3D12_MESSAGE
diff --git a/WickedEngine/Utility/dx12/d3d12video.h b/WickedEngine/Utility/dx12/d3d12video.h
index 32f4da0f3..e38f12f06 100644
--- a/WickedEngine/Utility/dx12/d3d12video.h
+++ b/WickedEngine/Utility/dx12/d3d12video.h
@@ -409,7 +409,7 @@ enum D3D12_VIDEO_PROCESS_FILTER_FLAGS
         D3D12_VIDEO_PROCESS_FILTER_FLAG_STEREO_ADJUSTMENT	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT ) 
     } 	D3D12_VIDEO_PROCESS_FILTER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS )
 typedef 
 enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS
     {
@@ -418,7 +418,7 @@ enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS
         D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_CUSTOM	= 0x80000000
     } 	D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS )
 typedef struct D3D12_VIDEO_PROCESS_ALPHA_BLENDING
     {
     BOOL Enable;
@@ -931,7 +931,7 @@ enum D3D12_VIDEO_DECODE_SUPPORT_FLAGS
         D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED	= 0x1
     } 	D3D12_VIDEO_DECODE_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS )
 typedef 
 enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS
     {
@@ -942,7 +942,7 @@ enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS
         D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_ALLOW_RESOLUTION_CHANGE_ON_NON_KEY_FRAME	= 0x8
     } 	D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS )
 typedef 
 enum D3D12_VIDEO_DECODE_STATUS
     {
@@ -1034,7 +1034,7 @@ enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS
         D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_A	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A ) 
     } 	D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS )
 typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM
     {
     UINT NodeIndex;
@@ -1054,7 +1054,7 @@ enum D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS
         D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_SUPPORTED	= 0x1
     } 	D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS )
 typedef 
 enum D3D12_VIDEO_SCALE_SUPPORT_FLAGS
     {
@@ -1063,7 +1063,7 @@ enum D3D12_VIDEO_SCALE_SUPPORT_FLAGS
         D3D12_VIDEO_SCALE_SUPPORT_FLAG_EVEN_DIMENSIONS_ONLY	= 0x2
     } 	D3D12_VIDEO_SCALE_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_SCALE_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_SCALE_SUPPORT_FLAGS )
 typedef struct D3D12_VIDEO_SCALE_SUPPORT
     {
     D3D12_VIDEO_SIZE_RANGE OutputSizeRange;
@@ -1354,7 +1354,7 @@ enum D3D12_VIDEO_PROCESS_FEATURE_FLAGS
         D3D12_VIDEO_PROCESS_FEATURE_FLAG_PIXEL_ASPECT_RATIO	= 0x40
     } 	D3D12_VIDEO_PROCESS_FEATURE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FEATURE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FEATURE_FLAGS )
 typedef 
 enum D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS
     {
@@ -1370,7 +1370,7 @@ enum D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS
         D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_CUSTOM	= 0x80000000
     } 	D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS )
 typedef 
 enum D3D12_VIDEO_PROCESS_ORIENTATION
     {
@@ -1392,7 +1392,7 @@ enum D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS
         D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_REPEAT	= 0x2
     } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS )
 typedef struct D3D12_VIDEO_PROCESS_FILTER_RANGE
     {
     INT Minimum;
@@ -1408,7 +1408,7 @@ enum D3D12_VIDEO_PROCESS_SUPPORT_FLAGS
         D3D12_VIDEO_PROCESS_SUPPORT_FLAG_SUPPORTED	= 0x1
     } 	D3D12_VIDEO_PROCESS_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_SUPPORT_FLAGS )
 typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT
     {
     UINT NodeIndex;
@@ -2763,7 +2763,7 @@ enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS
         D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_16X16	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16 ) 
     } 	D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS )
 typedef 
 enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION
     {
@@ -2777,7 +2777,7 @@ enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS
         D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_QUARTER_PEL	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL ) 
     } 	D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS )
 typedef struct D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT
     {
     UINT NodeIndex;
@@ -3707,7 +3707,7 @@ enum D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS
         D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_SUPPORTED	= 0x1
     } 	D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS )
 typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES
     {
     UINT NodeIndex;
@@ -3782,7 +3782,7 @@ enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS
         D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_WRITE	= 0x2
     } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS )
 typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT
     {
     UINT NodeIndex;
@@ -6420,7 +6420,7 @@ enum D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS
         D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_DELTA_LF_PARAMS	= 0x2000000
     } 	D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_AV1_TX_MODE
     {
@@ -6438,7 +6438,7 @@ enum D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS
         D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAG_SELECT	= ( 1 << D3D12_VIDEO_ENCODER_AV1_TX_MODE_SELECT ) 
     } 	D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS
     {
@@ -6460,7 +6460,7 @@ enum D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS
         D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAG_SWITCHABLE	= ( 1 << D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_SWITCHABLE ) 
     } 	D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE
     {
@@ -6500,7 +6500,7 @@ enum D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS
         D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_GLOBALMV	= ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_GLOBALMV ) 
     } 	D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE
     {
@@ -6530,7 +6530,7 @@ enum D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS
         D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAG_256x256	= 0x8
     } 	D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION
     {
@@ -6550,7 +6550,7 @@ enum D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS
         D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAG_AFFINE	= ( 1 << D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_AFFINE ) 
     } 	D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS
     {
@@ -6566,7 +6566,7 @@ enum D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS
         D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_REFERENCE_INDICES	= 0x100
     } 	D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION_SUPPORT
     {
     D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS SupportedFeatureFlags;
@@ -6600,7 +6600,7 @@ enum D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS
         D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAG_SWITCH_FRAME	= ( 1 << D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_SWITCH_FRAME ) 
     } 	D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_AV1_COMP_PREDICTION_TYPE
     {
@@ -6667,7 +6667,7 @@ enum D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS
         D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ALLOW_HIGH_PRECISION_MV	= 0x4000
     } 	D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_AV1_RESTORATION_CONFIG
     {
     D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE FrameRestorationType[ 3 ];
@@ -6819,7 +6819,7 @@ enum D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS
         D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QUALITY_VS_SPEED	= 0x80
     } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP
     {
     UINT ConstantQP_FullIntracodedFrame;
@@ -7165,7 +7165,7 @@ enum D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS
         D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_TOTAL_TILES	= 0x80
     } 	D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_SUPPORT
     {
     BOOL Use128SuperBlocks;
@@ -7209,7 +7209,7 @@ enum D3D12_VIDEO_ENCODER_HEAP_FLAGS
         D3D12_VIDEO_ENCODER_HEAP_FLAG_NONE	= 0
     } 	D3D12_VIDEO_ENCODER_HEAP_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_HEAP_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_HEAP_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_HEAP_DESC
     {
     UINT NodeMask;
@@ -7243,7 +7243,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS
         D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_NUM_REF_IDX_ACTIVE_OVERRIDE_FLAG_SLICE_SUPPORT	= 0x80
     } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES
     {
@@ -7269,7 +7269,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS
         D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING ) 
     } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264
     {
     D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS SupportFlags;
@@ -7314,7 +7314,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS
         D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CHROMA_QP_OFFSET_LIST_ENABLED_FLAG_REQUIRED	= 0x80000000
     } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE
     {
@@ -7352,7 +7352,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1
         D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG1_SEPARATE_COLOUR_PLANE_REQUIRED	= 0x2
     } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1)
 typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC1
     {
     D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS SupportFlags;
@@ -7449,10 +7449,11 @@ enum D3D12_VIDEO_ENCODER_SUPPORT_FLAGS
         D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SEQUENCE_GOP_RECONFIGURATION_AVAILABLE	= 0x800,
         D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE	= 0x1000,
         D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_EXTENSION1_SUPPORT	= 0x2000,
-        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_QUALITY_VS_SPEED_AVAILABLE	= 0x4000
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_QUALITY_VS_SPEED_AVAILABLE	= 0x4000,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_READABLE_RECONSTRUCTED_PICTURE_LAYOUT_AVAILABLE	= 0x8000
     } 	D3D12_VIDEO_ENCODER_SUPPORT_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SUPPORT_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SUPPORT_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS
     {
@@ -7463,7 +7464,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS
         D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x8
     } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS)
 typedef 
 enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES
     {
@@ -7502,7 +7503,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS
         D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_SEPARATE_COLOUR_PLANE	= 0x10000
     } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC
     {
     D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS ConfigurationFlags;
@@ -7565,7 +7566,7 @@ enum D3D12_VIDEO_ENCODER_VALIDATION_FLAGS
         D3D12_VIDEO_ENCODER_VALIDATION_FLAG_SUBREGION_LAYOUT_DATA_NOT_SUPPORTED	= 0x1000
     } 	D3D12_VIDEO_ENCODER_VALIDATION_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_VALIDATION_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_VALIDATION_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264
     {
     UINT GOPLength;
@@ -7676,7 +7677,7 @@ enum D3D12_VIDEO_ENCODER_FLAGS
         D3D12_VIDEO_ENCODER_FLAG_NONE	= 0
     } 	D3D12_VIDEO_ENCODER_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_DESC
     {
     UINT NodeMask;
@@ -8334,7 +8335,7 @@ enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS
         D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_NUM_REF_IDX_ACTIVE_OVERRIDE_FLAG_SLICE	= 0x2
     } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION
     {
     UCHAR memory_management_control_operation;
@@ -8405,7 +8406,7 @@ enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS
         D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_CHROMA_QP_OFFSET_LIST	= 0x8
     } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC
     {
     D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS Flags;
@@ -8481,7 +8482,7 @@ enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS
         D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE	= 0x1
     } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC
     {
     UINT IntraRefreshFrameIndex;
@@ -8501,7 +8502,7 @@ enum D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS
         D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_GOP_SEQUENCE_CHANGE	= 0x10
     } 	D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC
     {
     D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS Flags;
@@ -8552,7 +8553,7 @@ enum D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS
         D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_METADATA_BUFFER_SOURCE	= 0x10
     } 	D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS);
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS)
 typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS
     {
     UINT64 AverageQP;
diff --git a/WickedEngine/Utility/dx12/d3dx12_core.h b/WickedEngine/Utility/dx12/d3dx12_core.h
index a93ff5b5c..87814fb8e 100644
--- a/WickedEngine/Utility/dx12/d3dx12_core.h
+++ b/WickedEngine/Utility/dx12/d3dx12_core.h
@@ -1495,6 +1495,7 @@ inline const CD3DX12_RESOURCE_DESC1* D3DX12ConditionallyExpandAPIDesc(
     }
 }
 
+
 //------------------------------------------------------------------------------------------------
 struct CD3DX12_VIEW_INSTANCING_DESC : public D3D12_VIEW_INSTANCING_DESC
 {
@@ -1532,4 +1533,5 @@ struct CD3DX12_RT_FORMAT_ARRAY : public D3D12_RT_FORMAT_ARRAY
         memcpy(RTFormats, pFormats, sizeof(RTFormats));
         // assumes ARRAY_SIZE(pFormats) == ARRAY_SIZE(RTFormats)
     }
-};
\ No newline at end of file
+};
+
diff --git a/WickedEngine/Utility/dx12/d3dx12_pipeline_state_stream.h b/WickedEngine/Utility/dx12/d3dx12_pipeline_state_stream.h
index 5591a9329..a3ee813c6 100644
--- a/WickedEngine/Utility/dx12/d3dx12_pipeline_state_stream.h
+++ b/WickedEngine/Utility/dx12/d3dx12_pipeline_state_stream.h
@@ -11,8 +11,8 @@
 #error D3DX12 requires C++
 #endif
 
-#include "d3d12.h"
 #include "d3dx12_default.h"
+#include "d3d12.h"
 #include "d3dx12_core.h"
 
 //------------------------------------------------------------------------------------------------
@@ -1494,3 +1494,4 @@ inline HRESULT D3DX12ParsePipelineStream(const D3D12_PIPELINE_STATE_STREAM_DESC&
 
     return S_OK;
 }
+
diff --git a/WickedEngine/Utility/dx12/d3dx12_render_pass.h b/WickedEngine/Utility/dx12/d3dx12_render_pass.h
index fc032f86c..c88fbdf1b 100644
--- a/WickedEngine/Utility/dx12/d3dx12_render_pass.h
+++ b/WickedEngine/Utility/dx12/d3dx12_render_pass.h
@@ -60,6 +60,8 @@ inline bool operator==( const D3D12_RENDER_PASS_BEGINNING_ACCESS &a, const D3D12
         if (!(a.PreserveLocal == b.PreserveLocal)) return false;
         break;
 #endif
+    default:
+        break;
     }
     return true;
 }
@@ -79,8 +81,9 @@ inline bool operator==(const D3D12_RENDER_PASS_ENDING_ACCESS& a, const D3D12_REN
         if (!(a.PreserveLocal == b.PreserveLocal)) return false;
         break;
 #endif
+    default:
+        break;
     }
-
     return true;
 }
 
diff --git a/WickedEngine/Utility/dx12/d3dx12_resource_helpers.h b/WickedEngine/Utility/dx12/d3dx12_resource_helpers.h
index 902ec0cd6..c0c540c52 100644
--- a/WickedEngine/Utility/dx12/d3dx12_resource_helpers.h
+++ b/WickedEngine/Utility/dx12/d3dx12_resource_helpers.h
@@ -11,9 +11,9 @@
 #error D3DX12 requires C++
 #endif
 
+#include "d3dx12_property_format_table.h"
 #include "d3d12.h"
 #include "d3dx12_core.h"
-#include "d3dx12_property_format_table.h"
 //------------------------------------------------------------------------------------------------
 template <typename T, typename U, typename V>
 inline void D3D12DecomposeSubresource( UINT Subresource, UINT MipLevels, UINT ArraySize, _Out_ T& MipSlice, _Out_ U& ArraySlice, _Out_ V& PlaneSlice ) noexcept
diff --git a/WickedEngine/Utility/dx12/d3dx12_state_object.h b/WickedEngine/Utility/dx12/d3dx12_state_object.h
index f74d25773..b460c769d 100644
--- a/WickedEngine/Utility/dx12/d3dx12_state_object.h
+++ b/WickedEngine/Utility/dx12/d3dx12_state_object.h
@@ -11,8 +11,8 @@
 #error D3DX12 requires C++
 #endif
 
-#include "d3d12.h"
 #include "d3dx12_default.h"
+#include "d3d12.h"
 #include "d3dx12_core.h"
 
 //================================================================================================
@@ -71,8 +71,10 @@ public:
             ownedSubobject->Finalize();
         }
 
+#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
         m_RepointedSubobjectVectors.clear();
         m_RepointedPrograms.clear();
+#endif
         m_RepointedAssociations.clear();
         m_SubobjectArray.clear();
         m_SubobjectArray.reserve(m_Desc.NumSubobjects);
@@ -100,6 +102,7 @@ public:
                 m_RepointedAssociations.push_back(Repointed);
                 m_SubobjectArray[i].pDesc = &m_RepointedAssociations.back();
             }
+#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
             else if (m_SubobjectArray[i].Type == D3D12_STATE_SUBOBJECT_TYPE_GENERIC_PROGRAM)
             {
                 auto originalGenericProgramDesc =
@@ -122,6 +125,7 @@ public:
                 m_RepointedPrograms.push_back(Repointed);
                 m_SubobjectArray[i].pDesc = &m_RepointedPrograms.back();
             }
+#endif
         }
         // Below: using ugly way to get pointer in case .data() is not defined
         m_Desc.pSubobjects = m_Desc.NumSubobjects ? &m_SubobjectArray[0] : nullptr;
@@ -185,8 +189,10 @@ private:
         m_SubobjectList.clear();
         m_SubobjectArray.clear();
         m_RepointedAssociations.clear();
+#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
         m_RepointedSubobjectVectors.clear();
         m_RepointedPrograms.clear();
+#endif
     }
     typedef struct SUBOBJECT_WRAPPER : public D3D12_STATE_SUBOBJECT
     {
@@ -202,10 +208,12 @@ private:
         m_RepointedAssociations; // subobject type that contains pointers to other subobjects,
                                  // repointed to flattened array
 
+#if defined(D3D12_SDK_VERSION) && (D3D12_SDK_VERSION >= 612)
     std::list<std::vector<D3D12_STATE_SUBOBJECT const*>>
         m_RepointedSubobjectVectors;
     std::list<D3D12_GENERIC_PROGRAM_DESC>
         m_RepointedPrograms;
+#endif
 
     template<typename CStr, typename StdStr>
     class StringContainer
@@ -317,6 +325,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_DXIL_LIBRARY_SUBOBJECT(const CD3DX12_DXIL_LIBRARY_SUBOBJECT& other) = delete;
+    CD3DX12_DXIL_LIBRARY_SUBOBJECT& operator=(const CD3DX12_DXIL_LIBRARY_SUBOBJECT& other) = delete;
+    CD3DX12_DXIL_LIBRARY_SUBOBJECT(CD3DX12_DXIL_LIBRARY_SUBOBJECT&& other) = default;
+    CD3DX12_DXIL_LIBRARY_SUBOBJECT& operator=(CD3DX12_DXIL_LIBRARY_SUBOBJECT&& other) = default;
     void SetDXILLibrary(const D3D12_SHADER_BYTECODE* pCode) noexcept
     {
         static const D3D12_SHADER_BYTECODE Default = {};
@@ -383,6 +395,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_EXISTING_COLLECTION_SUBOBJECT(const CD3DX12_EXISTING_COLLECTION_SUBOBJECT& other) = delete;
+    CD3DX12_EXISTING_COLLECTION_SUBOBJECT& operator=(const CD3DX12_EXISTING_COLLECTION_SUBOBJECT& other) = delete;
+    CD3DX12_EXISTING_COLLECTION_SUBOBJECT(CD3DX12_EXISTING_COLLECTION_SUBOBJECT&& other) = default;
+    CD3DX12_EXISTING_COLLECTION_SUBOBJECT& operator=(CD3DX12_EXISTING_COLLECTION_SUBOBJECT&& other) = default;
     void SetExistingCollection(ID3D12StateObject*pExistingCollection) noexcept
     {
         m_Desc.pExistingCollection = pExistingCollection;
@@ -451,6 +467,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(const CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& other) = delete;
+    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& operator=(const CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& other) = delete;
+    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT(CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT&& other) = default;
+    CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT& operator=(CD3DX12_SUBOBJECT_TO_EXPORTS_ASSOCIATION_SUBOBJECT&& other) = default;
     void SetSubobjectToAssociate(const D3D12_STATE_SUBOBJECT& SubobjectToAssociate) noexcept
     {
         m_Desc.pSubobjectToAssociate = &SubobjectToAssociate;
@@ -509,6 +529,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(const CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& other) = delete;
+    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& operator=(const CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& other) = delete;
+    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION(CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&& other) = default;
+    CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION& operator=(CD3DX12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION&& other) = default;
     void SetSubobjectNameToAssociate(LPCWSTR SubobjectToAssociate)
     {
         m_Desc.SubobjectToAssociate = m_SubobjectName.LocalCopy(SubobjectToAssociate, true);
@@ -569,6 +593,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_HIT_GROUP_SUBOBJECT(const CD3DX12_HIT_GROUP_SUBOBJECT& other) = delete;
+    CD3DX12_HIT_GROUP_SUBOBJECT& operator=(const CD3DX12_HIT_GROUP_SUBOBJECT& other) = delete;
+    CD3DX12_HIT_GROUP_SUBOBJECT(CD3DX12_HIT_GROUP_SUBOBJECT&& other) = default;
+    CD3DX12_HIT_GROUP_SUBOBJECT& operator=(CD3DX12_HIT_GROUP_SUBOBJECT&& other) = default;
     void SetHitGroupExport(LPCWSTR exportName)
     {
         m_Desc.HitGroupExport = m_Strings[0].LocalCopy(exportName, true);
@@ -622,6 +650,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(const CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& other) = delete;
+    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& operator=(const CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& other) = delete;
+    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT(CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT&& other) = default;
+    CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT& operator=(CD3DX12_RAYTRACING_SHADER_CONFIG_SUBOBJECT&& other) = default;
     void Config(UINT MaxPayloadSizeInBytes, UINT MaxAttributeSizeInBytes) noexcept
     {
         m_Desc.MaxPayloadSizeInBytes = MaxPayloadSizeInBytes;
@@ -656,6 +688,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(const CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& other) = delete;
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& operator=(const CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& other) = delete;
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT(CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT&& other) = default;
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT& operator=(CD3DX12_RAYTRACING_PIPELINE_CONFIG_SUBOBJECT&& other) = default;
     void Config(UINT MaxTraceRecursionDepth) noexcept
     {
         m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
@@ -689,6 +725,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(const CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& other) = delete;
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& operator=(const CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& other) = delete;
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT(CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT&& other) = default;
+    CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT& operator=(CD3DX12_RAYTRACING_PIPELINE_CONFIG1_SUBOBJECT&& other) = default;
     void Config(UINT MaxTraceRecursionDepth, D3D12_RAYTRACING_PIPELINE_FLAGS Flags) noexcept
     {
         m_Desc.MaxTraceRecursionDepth = MaxTraceRecursionDepth;
@@ -723,6 +763,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(const CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
+    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& operator=(const CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
+    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
+    CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT& operator=(CD3DX12_GLOBAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
     void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
     {
         m_pRootSig = pRootSig;
@@ -756,6 +800,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(const CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
+    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& operator=(const CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& other) = delete;
+    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT(CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
+    CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT& operator=(CD3DX12_LOCAL_ROOT_SIGNATURE_SUBOBJECT&& other) = default;
     void SetRootSignature(ID3D12RootSignature* pRootSig) noexcept
     {
         m_pRootSig = pRootSig;
@@ -789,6 +837,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(const CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& other) = delete;
+    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& operator=(const CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& other) = delete;
+    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT(CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT&& other) = default;
+    CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT& operator=(CD3DX12_STATE_OBJECT_CONFIG_SUBOBJECT&& other) = default;
     void SetFlags(D3D12_STATE_OBJECT_FLAGS Flags) noexcept
     {
         m_Desc.Flags = Flags;
@@ -822,6 +874,10 @@ public:
         Init();
         AddToStateObject(ContainingStateObject);
     }
+    CD3DX12_NODE_MASK_SUBOBJECT(const CD3DX12_NODE_MASK_SUBOBJECT& other) = delete;
+    CD3DX12_NODE_MASK_SUBOBJECT& operator=(const CD3DX12_NODE_MASK_SUBOBJECT& other) = delete;
+    CD3DX12_NODE_MASK_SUBOBJECT(CD3DX12_NODE_MASK_SUBOBJECT&& other) = default;
+    CD3DX12_NODE_MASK_SUBOBJECT& operator=(CD3DX12_NODE_MASK_SUBOBJECT&& other) = default;
     void SetNodeMask(UINT NodeMask) noexcept
     {
         m_Desc.NodeMask = NodeMask;
@@ -2151,3 +2207,4 @@ private:
 #undef D3DX12_COM_PTR
 #undef D3DX12_COM_PTR_GET
 #undef D3DX12_COM_PTR_ADDRESSOF
+
diff --git a/WickedEngine/Utility/dx12/dxcore_interface.h b/WickedEngine/Utility/dx12/dxcore_interface.h
index c3cc962f8..318208ea3 100644
--- a/WickedEngine/Utility/dx12/dxcore_interface.h
+++ b/WickedEngine/Utility/dx12/dxcore_interface.h
@@ -92,7 +92,7 @@ enum class DXCoreRuntimeFilterFlags : uint32_t
     D3D12 = 0x2
 };
 
-DEFINE_ENUM_FLAG_OPERATORS(DXCoreRuntimeFilterFlags);
+DEFINE_ENUM_FLAG_OPERATORS(DXCoreRuntimeFilterFlags)
 
 enum class DXCoreHardwareTypeFilterFlags : uint32_t
 {
@@ -103,7 +103,7 @@ enum class DXCoreHardwareTypeFilterFlags : uint32_t
     MediaAccelerator = 0x8
 };
 
-DEFINE_ENUM_FLAG_OPERATORS(DXCoreHardwareTypeFilterFlags);
+DEFINE_ENUM_FLAG_OPERATORS(DXCoreHardwareTypeFilterFlags)
 
 struct DXCoreHardwareID
 {
diff --git a/WickedEngine/Utility/include/spirv/unified1/spirv.h b/WickedEngine/Utility/include/spirv/unified1/spirv.h
index 949f1980e..65becfd76 100644
--- a/WickedEngine/Utility/include/spirv/unified1/spirv.h
+++ b/WickedEngine/Utility/include/spirv/unified1/spirv.h
@@ -1,20 +1,20 @@
 /*
 ** Copyright (c) 2014-2020 The Khronos Group Inc.
-** 
+**
 ** Permission is hereby granted, free of charge, to any person obtaining a copy
 ** of this software and/or associated documentation files (the "Materials"),
 ** to deal in the Materials without restriction, including without limitation
 ** the rights to use, copy, modify, merge, publish, distribute, sublicense,
 ** and/or sell copies of the Materials, and to permit persons to whom the
 ** Materials are furnished to do so, subject to the following conditions:
-** 
+**
 ** The above copyright notice and this permission notice shall be included in
 ** all copies or substantial portions of the Materials.
-** 
+**
 ** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
 ** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-** 
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+**
 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
@@ -31,17 +31,22 @@
 
 /*
 ** Enumeration tokens for SPIR-V, in various styles:
-**   C, C++, C++11, JSON, Lua, Python, C#, D
-** 
+**   C, C++, C++11, JSON, Lua, Python, C#, D, Beef
+**
 ** - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
 ** - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
-** - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+** - C++11 will use enum classes in the spv namespace, e.g.:
+*spv::SourceLanguage::GLSL
 ** - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
 ** - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
-** - C# will use enum classes in the Specification class located in the "Spv" namespace,
+** - C# will use enum classes in the Specification class located in the "Spv"
+*namespace,
 **     e.g.: Spv.Specification.SourceLanguage.GLSL
 ** - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
-** 
+** - Beef will use enum classes in the Specification class located in the "Spv"
+*namespace,
+**     e.g.: Spv.Specification.SourceLanguage.GLSL
+**
 ** Some tokens act like mask values, which can be OR'd together,
 ** while others are mutually exclusive.  The mask-like ones have
 ** "Mask" in their name, and a parallel enum that has the shift
@@ -53,2140 +58,4833 @@
 
 typedef unsigned int SpvId;
 
-#define SPV_VERSION 0x10500
-#define SPV_REVISION 4
+#define SPV_VERSION 0x10600
+#define SPV_REVISION 1
 
 static const unsigned int SpvMagicNumber = 0x07230203;
-static const unsigned int SpvVersion = 0x00010500;
-static const unsigned int SpvRevision = 4;
+static const unsigned int SpvVersion = 0x00010600;
+static const unsigned int SpvRevision = 1;
 static const unsigned int SpvOpCodeMask = 0xffff;
 static const unsigned int SpvWordCountShift = 16;
 
 typedef enum SpvSourceLanguage_ {
-    SpvSourceLanguageUnknown = 0,
-    SpvSourceLanguageESSL = 1,
-    SpvSourceLanguageGLSL = 2,
-    SpvSourceLanguageOpenCL_C = 3,
-    SpvSourceLanguageOpenCL_CPP = 4,
-    SpvSourceLanguageHLSL = 5,
-    SpvSourceLanguageMax = 0x7fffffff,
+  SpvSourceLanguageUnknown = 0,
+  SpvSourceLanguageESSL = 1,
+  SpvSourceLanguageGLSL = 2,
+  SpvSourceLanguageOpenCL_C = 3,
+  SpvSourceLanguageOpenCL_CPP = 4,
+  SpvSourceLanguageHLSL = 5,
+  SpvSourceLanguageCPP_for_OpenCL = 6,
+  SpvSourceLanguageSYCL = 7,
+  SpvSourceLanguageHERO_C = 8,
+  SpvSourceLanguageNZSL = 9,
+  SpvSourceLanguageMax = 0x7fffffff,
 } SpvSourceLanguage;
 
 typedef enum SpvExecutionModel_ {
-    SpvExecutionModelVertex = 0,
-    SpvExecutionModelTessellationControl = 1,
-    SpvExecutionModelTessellationEvaluation = 2,
-    SpvExecutionModelGeometry = 3,
-    SpvExecutionModelFragment = 4,
-    SpvExecutionModelGLCompute = 5,
-    SpvExecutionModelKernel = 6,
-    SpvExecutionModelTaskNV = 5267,
-    SpvExecutionModelMeshNV = 5268,
-    SpvExecutionModelRayGenerationKHR = 5313,
-    SpvExecutionModelRayGenerationNV = 5313,
-    SpvExecutionModelIntersectionKHR = 5314,
-    SpvExecutionModelIntersectionNV = 5314,
-    SpvExecutionModelAnyHitKHR = 5315,
-    SpvExecutionModelAnyHitNV = 5315,
-    SpvExecutionModelClosestHitKHR = 5316,
-    SpvExecutionModelClosestHitNV = 5316,
-    SpvExecutionModelMissKHR = 5317,
-    SpvExecutionModelMissNV = 5317,
-    SpvExecutionModelCallableKHR = 5318,
-    SpvExecutionModelCallableNV = 5318,
-    SpvExecutionModelMax = 0x7fffffff,
+  SpvExecutionModelVertex = 0,
+  SpvExecutionModelTessellationControl = 1,
+  SpvExecutionModelTessellationEvaluation = 2,
+  SpvExecutionModelGeometry = 3,
+  SpvExecutionModelFragment = 4,
+  SpvExecutionModelGLCompute = 5,
+  SpvExecutionModelKernel = 6,
+  SpvExecutionModelTaskNV = 5267,
+  SpvExecutionModelMeshNV = 5268,
+  SpvExecutionModelRayGenerationKHR = 5313,
+  SpvExecutionModelRayGenerationNV = 5313,
+  SpvExecutionModelIntersectionKHR = 5314,
+  SpvExecutionModelIntersectionNV = 5314,
+  SpvExecutionModelAnyHitKHR = 5315,
+  SpvExecutionModelAnyHitNV = 5315,
+  SpvExecutionModelClosestHitKHR = 5316,
+  SpvExecutionModelClosestHitNV = 5316,
+  SpvExecutionModelMissKHR = 5317,
+  SpvExecutionModelMissNV = 5317,
+  SpvExecutionModelCallableKHR = 5318,
+  SpvExecutionModelCallableNV = 5318,
+  SpvExecutionModelTaskEXT = 5364,
+  SpvExecutionModelMeshEXT = 5365,
+  SpvExecutionModelMax = 0x7fffffff,
 } SpvExecutionModel;
 
 typedef enum SpvAddressingModel_ {
-    SpvAddressingModelLogical = 0,
-    SpvAddressingModelPhysical32 = 1,
-    SpvAddressingModelPhysical64 = 2,
-    SpvAddressingModelPhysicalStorageBuffer64 = 5348,
-    SpvAddressingModelPhysicalStorageBuffer64EXT = 5348,
-    SpvAddressingModelMax = 0x7fffffff,
+  SpvAddressingModelLogical = 0,
+  SpvAddressingModelPhysical32 = 1,
+  SpvAddressingModelPhysical64 = 2,
+  SpvAddressingModelPhysicalStorageBuffer64 = 5348,
+  SpvAddressingModelPhysicalStorageBuffer64EXT = 5348,
+  SpvAddressingModelMax = 0x7fffffff,
 } SpvAddressingModel;
 
 typedef enum SpvMemoryModel_ {
-    SpvMemoryModelSimple = 0,
-    SpvMemoryModelGLSL450 = 1,
-    SpvMemoryModelOpenCL = 2,
-    SpvMemoryModelVulkan = 3,
-    SpvMemoryModelVulkanKHR = 3,
-    SpvMemoryModelMax = 0x7fffffff,
+  SpvMemoryModelSimple = 0,
+  SpvMemoryModelGLSL450 = 1,
+  SpvMemoryModelOpenCL = 2,
+  SpvMemoryModelVulkan = 3,
+  SpvMemoryModelVulkanKHR = 3,
+  SpvMemoryModelMax = 0x7fffffff,
 } SpvMemoryModel;
 
 typedef enum SpvExecutionMode_ {
-    SpvExecutionModeInvocations = 0,
-    SpvExecutionModeSpacingEqual = 1,
-    SpvExecutionModeSpacingFractionalEven = 2,
-    SpvExecutionModeSpacingFractionalOdd = 3,
-    SpvExecutionModeVertexOrderCw = 4,
-    SpvExecutionModeVertexOrderCcw = 5,
-    SpvExecutionModePixelCenterInteger = 6,
-    SpvExecutionModeOriginUpperLeft = 7,
-    SpvExecutionModeOriginLowerLeft = 8,
-    SpvExecutionModeEarlyFragmentTests = 9,
-    SpvExecutionModePointMode = 10,
-    SpvExecutionModeXfb = 11,
-    SpvExecutionModeDepthReplacing = 12,
-    SpvExecutionModeDepthGreater = 14,
-    SpvExecutionModeDepthLess = 15,
-    SpvExecutionModeDepthUnchanged = 16,
-    SpvExecutionModeLocalSize = 17,
-    SpvExecutionModeLocalSizeHint = 18,
-    SpvExecutionModeInputPoints = 19,
-    SpvExecutionModeInputLines = 20,
-    SpvExecutionModeInputLinesAdjacency = 21,
-    SpvExecutionModeTriangles = 22,
-    SpvExecutionModeInputTrianglesAdjacency = 23,
-    SpvExecutionModeQuads = 24,
-    SpvExecutionModeIsolines = 25,
-    SpvExecutionModeOutputVertices = 26,
-    SpvExecutionModeOutputPoints = 27,
-    SpvExecutionModeOutputLineStrip = 28,
-    SpvExecutionModeOutputTriangleStrip = 29,
-    SpvExecutionModeVecTypeHint = 30,
-    SpvExecutionModeContractionOff = 31,
-    SpvExecutionModeInitializer = 33,
-    SpvExecutionModeFinalizer = 34,
-    SpvExecutionModeSubgroupSize = 35,
-    SpvExecutionModeSubgroupsPerWorkgroup = 36,
-    SpvExecutionModeSubgroupsPerWorkgroupId = 37,
-    SpvExecutionModeLocalSizeId = 38,
-    SpvExecutionModeLocalSizeHintId = 39,
-    SpvExecutionModePostDepthCoverage = 4446,
-    SpvExecutionModeDenormPreserve = 4459,
-    SpvExecutionModeDenormFlushToZero = 4460,
-    SpvExecutionModeSignedZeroInfNanPreserve = 4461,
-    SpvExecutionModeRoundingModeRTE = 4462,
-    SpvExecutionModeRoundingModeRTZ = 4463,
-    SpvExecutionModeStencilRefReplacingEXT = 5027,
-    SpvExecutionModeOutputLinesNV = 5269,
-    SpvExecutionModeOutputPrimitivesNV = 5270,
-    SpvExecutionModeDerivativeGroupQuadsNV = 5289,
-    SpvExecutionModeDerivativeGroupLinearNV = 5290,
-    SpvExecutionModeOutputTrianglesNV = 5298,
-    SpvExecutionModePixelInterlockOrderedEXT = 5366,
-    SpvExecutionModePixelInterlockUnorderedEXT = 5367,
-    SpvExecutionModeSampleInterlockOrderedEXT = 5368,
-    SpvExecutionModeSampleInterlockUnorderedEXT = 5369,
-    SpvExecutionModeShadingRateInterlockOrderedEXT = 5370,
-    SpvExecutionModeShadingRateInterlockUnorderedEXT = 5371,
-    SpvExecutionModeMaxWorkgroupSizeINTEL = 5893,
-    SpvExecutionModeMaxWorkDimINTEL = 5894,
-    SpvExecutionModeNoGlobalOffsetINTEL = 5895,
-    SpvExecutionModeNumSIMDWorkitemsINTEL = 5896,
-    SpvExecutionModeMax = 0x7fffffff,
+  SpvExecutionModeInvocations = 0,
+  SpvExecutionModeSpacingEqual = 1,
+  SpvExecutionModeSpacingFractionalEven = 2,
+  SpvExecutionModeSpacingFractionalOdd = 3,
+  SpvExecutionModeVertexOrderCw = 4,
+  SpvExecutionModeVertexOrderCcw = 5,
+  SpvExecutionModePixelCenterInteger = 6,
+  SpvExecutionModeOriginUpperLeft = 7,
+  SpvExecutionModeOriginLowerLeft = 8,
+  SpvExecutionModeEarlyFragmentTests = 9,
+  SpvExecutionModePointMode = 10,
+  SpvExecutionModeXfb = 11,
+  SpvExecutionModeDepthReplacing = 12,
+  SpvExecutionModeDepthGreater = 14,
+  SpvExecutionModeDepthLess = 15,
+  SpvExecutionModeDepthUnchanged = 16,
+  SpvExecutionModeLocalSize = 17,
+  SpvExecutionModeLocalSizeHint = 18,
+  SpvExecutionModeInputPoints = 19,
+  SpvExecutionModeInputLines = 20,
+  SpvExecutionModeInputLinesAdjacency = 21,
+  SpvExecutionModeTriangles = 22,
+  SpvExecutionModeInputTrianglesAdjacency = 23,
+  SpvExecutionModeQuads = 24,
+  SpvExecutionModeIsolines = 25,
+  SpvExecutionModeOutputVertices = 26,
+  SpvExecutionModeOutputPoints = 27,
+  SpvExecutionModeOutputLineStrip = 28,
+  SpvExecutionModeOutputTriangleStrip = 29,
+  SpvExecutionModeVecTypeHint = 30,
+  SpvExecutionModeContractionOff = 31,
+  SpvExecutionModeInitializer = 33,
+  SpvExecutionModeFinalizer = 34,
+  SpvExecutionModeSubgroupSize = 35,
+  SpvExecutionModeSubgroupsPerWorkgroup = 36,
+  SpvExecutionModeSubgroupsPerWorkgroupId = 37,
+  SpvExecutionModeLocalSizeId = 38,
+  SpvExecutionModeLocalSizeHintId = 39,
+  SpvExecutionModeNonCoherentColorAttachmentReadEXT = 4169,
+  SpvExecutionModeNonCoherentDepthAttachmentReadEXT = 4170,
+  SpvExecutionModeNonCoherentStencilAttachmentReadEXT = 4171,
+  SpvExecutionModeSubgroupUniformControlFlowKHR = 4421,
+  SpvExecutionModePostDepthCoverage = 4446,
+  SpvExecutionModeDenormPreserve = 4459,
+  SpvExecutionModeDenormFlushToZero = 4460,
+  SpvExecutionModeSignedZeroInfNanPreserve = 4461,
+  SpvExecutionModeRoundingModeRTE = 4462,
+  SpvExecutionModeRoundingModeRTZ = 4463,
+  SpvExecutionModeEarlyAndLateFragmentTestsAMD = 5017,
+  SpvExecutionModeStencilRefReplacingEXT = 5027,
+  SpvExecutionModeStencilRefUnchangedFrontAMD = 5079,
+  SpvExecutionModeStencilRefGreaterFrontAMD = 5080,
+  SpvExecutionModeStencilRefLessFrontAMD = 5081,
+  SpvExecutionModeStencilRefUnchangedBackAMD = 5082,
+  SpvExecutionModeStencilRefGreaterBackAMD = 5083,
+  SpvExecutionModeStencilRefLessBackAMD = 5084,
+  SpvExecutionModeOutputLinesEXT = 5269,
+  SpvExecutionModeOutputLinesNV = 5269,
+  SpvExecutionModeOutputPrimitivesEXT = 5270,
+  SpvExecutionModeOutputPrimitivesNV = 5270,
+  SpvExecutionModeDerivativeGroupQuadsNV = 5289,
+  SpvExecutionModeDerivativeGroupLinearNV = 5290,
+  SpvExecutionModeOutputTrianglesEXT = 5298,
+  SpvExecutionModeOutputTrianglesNV = 5298,
+  SpvExecutionModePixelInterlockOrderedEXT = 5366,
+  SpvExecutionModePixelInterlockUnorderedEXT = 5367,
+  SpvExecutionModeSampleInterlockOrderedEXT = 5368,
+  SpvExecutionModeSampleInterlockUnorderedEXT = 5369,
+  SpvExecutionModeShadingRateInterlockOrderedEXT = 5370,
+  SpvExecutionModeShadingRateInterlockUnorderedEXT = 5371,
+  SpvExecutionModeSharedLocalMemorySizeINTEL = 5618,
+  SpvExecutionModeRoundingModeRTPINTEL = 5620,
+  SpvExecutionModeRoundingModeRTNINTEL = 5621,
+  SpvExecutionModeFloatingPointModeALTINTEL = 5622,
+  SpvExecutionModeFloatingPointModeIEEEINTEL = 5623,
+  SpvExecutionModeMaxWorkgroupSizeINTEL = 5893,
+  SpvExecutionModeMaxWorkDimINTEL = 5894,
+  SpvExecutionModeNoGlobalOffsetINTEL = 5895,
+  SpvExecutionModeNumSIMDWorkitemsINTEL = 5896,
+  SpvExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
+  SpvExecutionModeStreamingInterfaceINTEL = 6154,
+  SpvExecutionModeRegisterMapInterfaceINTEL = 6160,
+  SpvExecutionModeNamedBarrierCountINTEL = 6417,
+  SpvExecutionModeMax = 0x7fffffff,
 } SpvExecutionMode;
 
 typedef enum SpvStorageClass_ {
-    SpvStorageClassUniformConstant = 0,
-    SpvStorageClassInput = 1,
-    SpvStorageClassUniform = 2,
-    SpvStorageClassOutput = 3,
-    SpvStorageClassWorkgroup = 4,
-    SpvStorageClassCrossWorkgroup = 5,
-    SpvStorageClassPrivate = 6,
-    SpvStorageClassFunction = 7,
-    SpvStorageClassGeneric = 8,
-    SpvStorageClassPushConstant = 9,
-    SpvStorageClassAtomicCounter = 10,
-    SpvStorageClassImage = 11,
-    SpvStorageClassStorageBuffer = 12,
-    SpvStorageClassCallableDataKHR = 5328,
-    SpvStorageClassCallableDataNV = 5328,
-    SpvStorageClassIncomingCallableDataKHR = 5329,
-    SpvStorageClassIncomingCallableDataNV = 5329,
-    SpvStorageClassRayPayloadKHR = 5338,
-    SpvStorageClassRayPayloadNV = 5338,
-    SpvStorageClassHitAttributeKHR = 5339,
-    SpvStorageClassHitAttributeNV = 5339,
-    SpvStorageClassIncomingRayPayloadKHR = 5342,
-    SpvStorageClassIncomingRayPayloadNV = 5342,
-    SpvStorageClassShaderRecordBufferKHR = 5343,
-    SpvStorageClassShaderRecordBufferNV = 5343,
-    SpvStorageClassPhysicalStorageBuffer = 5349,
-    SpvStorageClassPhysicalStorageBufferEXT = 5349,
-    SpvStorageClassCodeSectionINTEL = 5605,
-    SpvStorageClassMax = 0x7fffffff,
+  SpvStorageClassUniformConstant = 0,
+  SpvStorageClassInput = 1,
+  SpvStorageClassUniform = 2,
+  SpvStorageClassOutput = 3,
+  SpvStorageClassWorkgroup = 4,
+  SpvStorageClassCrossWorkgroup = 5,
+  SpvStorageClassPrivate = 6,
+  SpvStorageClassFunction = 7,
+  SpvStorageClassGeneric = 8,
+  SpvStorageClassPushConstant = 9,
+  SpvStorageClassAtomicCounter = 10,
+  SpvStorageClassImage = 11,
+  SpvStorageClassStorageBuffer = 12,
+  SpvStorageClassTileImageEXT = 4172,
+  SpvStorageClassCallableDataKHR = 5328,
+  SpvStorageClassCallableDataNV = 5328,
+  SpvStorageClassIncomingCallableDataKHR = 5329,
+  SpvStorageClassIncomingCallableDataNV = 5329,
+  SpvStorageClassRayPayloadKHR = 5338,
+  SpvStorageClassRayPayloadNV = 5338,
+  SpvStorageClassHitAttributeKHR = 5339,
+  SpvStorageClassHitAttributeNV = 5339,
+  SpvStorageClassIncomingRayPayloadKHR = 5342,
+  SpvStorageClassIncomingRayPayloadNV = 5342,
+  SpvStorageClassShaderRecordBufferKHR = 5343,
+  SpvStorageClassShaderRecordBufferNV = 5343,
+  SpvStorageClassPhysicalStorageBuffer = 5349,
+  SpvStorageClassPhysicalStorageBufferEXT = 5349,
+  SpvStorageClassHitObjectAttributeNV = 5385,
+  SpvStorageClassTaskPayloadWorkgroupEXT = 5402,
+  SpvStorageClassCodeSectionINTEL = 5605,
+  SpvStorageClassDeviceOnlyINTEL = 5936,
+  SpvStorageClassHostOnlyINTEL = 5937,
+  SpvStorageClassMax = 0x7fffffff,
 } SpvStorageClass;
 
 typedef enum SpvDim_ {
-    SpvDim1D = 0,
-    SpvDim2D = 1,
-    SpvDim3D = 2,
-    SpvDimCube = 3,
-    SpvDimRect = 4,
-    SpvDimBuffer = 5,
-    SpvDimSubpassData = 6,
-    SpvDimMax = 0x7fffffff,
+  SpvDim1D = 0,
+  SpvDim2D = 1,
+  SpvDim3D = 2,
+  SpvDimCube = 3,
+  SpvDimRect = 4,
+  SpvDimBuffer = 5,
+  SpvDimSubpassData = 6,
+  SpvDimTileImageDataEXT = 4173,
+  SpvDimMax = 0x7fffffff,
 } SpvDim;
 
 typedef enum SpvSamplerAddressingMode_ {
-    SpvSamplerAddressingModeNone = 0,
-    SpvSamplerAddressingModeClampToEdge = 1,
-    SpvSamplerAddressingModeClamp = 2,
-    SpvSamplerAddressingModeRepeat = 3,
-    SpvSamplerAddressingModeRepeatMirrored = 4,
-    SpvSamplerAddressingModeMax = 0x7fffffff,
+  SpvSamplerAddressingModeNone = 0,
+  SpvSamplerAddressingModeClampToEdge = 1,
+  SpvSamplerAddressingModeClamp = 2,
+  SpvSamplerAddressingModeRepeat = 3,
+  SpvSamplerAddressingModeRepeatMirrored = 4,
+  SpvSamplerAddressingModeMax = 0x7fffffff,
 } SpvSamplerAddressingMode;
 
 typedef enum SpvSamplerFilterMode_ {
-    SpvSamplerFilterModeNearest = 0,
-    SpvSamplerFilterModeLinear = 1,
-    SpvSamplerFilterModeMax = 0x7fffffff,
+  SpvSamplerFilterModeNearest = 0,
+  SpvSamplerFilterModeLinear = 1,
+  SpvSamplerFilterModeMax = 0x7fffffff,
 } SpvSamplerFilterMode;
 
 typedef enum SpvImageFormat_ {
-    SpvImageFormatUnknown = 0,
-    SpvImageFormatRgba32f = 1,
-    SpvImageFormatRgba16f = 2,
-    SpvImageFormatR32f = 3,
-    SpvImageFormatRgba8 = 4,
-    SpvImageFormatRgba8Snorm = 5,
-    SpvImageFormatRg32f = 6,
-    SpvImageFormatRg16f = 7,
-    SpvImageFormatR11fG11fB10f = 8,
-    SpvImageFormatR16f = 9,
-    SpvImageFormatRgba16 = 10,
-    SpvImageFormatRgb10A2 = 11,
-    SpvImageFormatRg16 = 12,
-    SpvImageFormatRg8 = 13,
-    SpvImageFormatR16 = 14,
-    SpvImageFormatR8 = 15,
-    SpvImageFormatRgba16Snorm = 16,
-    SpvImageFormatRg16Snorm = 17,
-    SpvImageFormatRg8Snorm = 18,
-    SpvImageFormatR16Snorm = 19,
-    SpvImageFormatR8Snorm = 20,
-    SpvImageFormatRgba32i = 21,
-    SpvImageFormatRgba16i = 22,
-    SpvImageFormatRgba8i = 23,
-    SpvImageFormatR32i = 24,
-    SpvImageFormatRg32i = 25,
-    SpvImageFormatRg16i = 26,
-    SpvImageFormatRg8i = 27,
-    SpvImageFormatR16i = 28,
-    SpvImageFormatR8i = 29,
-    SpvImageFormatRgba32ui = 30,
-    SpvImageFormatRgba16ui = 31,
-    SpvImageFormatRgba8ui = 32,
-    SpvImageFormatR32ui = 33,
-    SpvImageFormatRgb10a2ui = 34,
-    SpvImageFormatRg32ui = 35,
-    SpvImageFormatRg16ui = 36,
-    SpvImageFormatRg8ui = 37,
-    SpvImageFormatR16ui = 38,
-    SpvImageFormatR8ui = 39,
-    SpvImageFormatR64ui = 40,
-    SpvImageFormatR64i = 41,
-    SpvImageFormatMax = 0x7fffffff,
+  SpvImageFormatUnknown = 0,
+  SpvImageFormatRgba32f = 1,
+  SpvImageFormatRgba16f = 2,
+  SpvImageFormatR32f = 3,
+  SpvImageFormatRgba8 = 4,
+  SpvImageFormatRgba8Snorm = 5,
+  SpvImageFormatRg32f = 6,
+  SpvImageFormatRg16f = 7,
+  SpvImageFormatR11fG11fB10f = 8,
+  SpvImageFormatR16f = 9,
+  SpvImageFormatRgba16 = 10,
+  SpvImageFormatRgb10A2 = 11,
+  SpvImageFormatRg16 = 12,
+  SpvImageFormatRg8 = 13,
+  SpvImageFormatR16 = 14,
+  SpvImageFormatR8 = 15,
+  SpvImageFormatRgba16Snorm = 16,
+  SpvImageFormatRg16Snorm = 17,
+  SpvImageFormatRg8Snorm = 18,
+  SpvImageFormatR16Snorm = 19,
+  SpvImageFormatR8Snorm = 20,
+  SpvImageFormatRgba32i = 21,
+  SpvImageFormatRgba16i = 22,
+  SpvImageFormatRgba8i = 23,
+  SpvImageFormatR32i = 24,
+  SpvImageFormatRg32i = 25,
+  SpvImageFormatRg16i = 26,
+  SpvImageFormatRg8i = 27,
+  SpvImageFormatR16i = 28,
+  SpvImageFormatR8i = 29,
+  SpvImageFormatRgba32ui = 30,
+  SpvImageFormatRgba16ui = 31,
+  SpvImageFormatRgba8ui = 32,
+  SpvImageFormatR32ui = 33,
+  SpvImageFormatRgb10a2ui = 34,
+  SpvImageFormatRg32ui = 35,
+  SpvImageFormatRg16ui = 36,
+  SpvImageFormatRg8ui = 37,
+  SpvImageFormatR16ui = 38,
+  SpvImageFormatR8ui = 39,
+  SpvImageFormatR64ui = 40,
+  SpvImageFormatR64i = 41,
+  SpvImageFormatMax = 0x7fffffff,
 } SpvImageFormat;
 
 typedef enum SpvImageChannelOrder_ {
-    SpvImageChannelOrderR = 0,
-    SpvImageChannelOrderA = 1,
-    SpvImageChannelOrderRG = 2,
-    SpvImageChannelOrderRA = 3,
-    SpvImageChannelOrderRGB = 4,
-    SpvImageChannelOrderRGBA = 5,
-    SpvImageChannelOrderBGRA = 6,
-    SpvImageChannelOrderARGB = 7,
-    SpvImageChannelOrderIntensity = 8,
-    SpvImageChannelOrderLuminance = 9,
-    SpvImageChannelOrderRx = 10,
-    SpvImageChannelOrderRGx = 11,
-    SpvImageChannelOrderRGBx = 12,
-    SpvImageChannelOrderDepth = 13,
-    SpvImageChannelOrderDepthStencil = 14,
-    SpvImageChannelOrdersRGB = 15,
-    SpvImageChannelOrdersRGBx = 16,
-    SpvImageChannelOrdersRGBA = 17,
-    SpvImageChannelOrdersBGRA = 18,
-    SpvImageChannelOrderABGR = 19,
-    SpvImageChannelOrderMax = 0x7fffffff,
+  SpvImageChannelOrderR = 0,
+  SpvImageChannelOrderA = 1,
+  SpvImageChannelOrderRG = 2,
+  SpvImageChannelOrderRA = 3,
+  SpvImageChannelOrderRGB = 4,
+  SpvImageChannelOrderRGBA = 5,
+  SpvImageChannelOrderBGRA = 6,
+  SpvImageChannelOrderARGB = 7,
+  SpvImageChannelOrderIntensity = 8,
+  SpvImageChannelOrderLuminance = 9,
+  SpvImageChannelOrderRx = 10,
+  SpvImageChannelOrderRGx = 11,
+  SpvImageChannelOrderRGBx = 12,
+  SpvImageChannelOrderDepth = 13,
+  SpvImageChannelOrderDepthStencil = 14,
+  SpvImageChannelOrdersRGB = 15,
+  SpvImageChannelOrdersRGBx = 16,
+  SpvImageChannelOrdersRGBA = 17,
+  SpvImageChannelOrdersBGRA = 18,
+  SpvImageChannelOrderABGR = 19,
+  SpvImageChannelOrderMax = 0x7fffffff,
 } SpvImageChannelOrder;
 
 typedef enum SpvImageChannelDataType_ {
-    SpvImageChannelDataTypeSnormInt8 = 0,
-    SpvImageChannelDataTypeSnormInt16 = 1,
-    SpvImageChannelDataTypeUnormInt8 = 2,
-    SpvImageChannelDataTypeUnormInt16 = 3,
-    SpvImageChannelDataTypeUnormShort565 = 4,
-    SpvImageChannelDataTypeUnormShort555 = 5,
-    SpvImageChannelDataTypeUnormInt101010 = 6,
-    SpvImageChannelDataTypeSignedInt8 = 7,
-    SpvImageChannelDataTypeSignedInt16 = 8,
-    SpvImageChannelDataTypeSignedInt32 = 9,
-    SpvImageChannelDataTypeUnsignedInt8 = 10,
-    SpvImageChannelDataTypeUnsignedInt16 = 11,
-    SpvImageChannelDataTypeUnsignedInt32 = 12,
-    SpvImageChannelDataTypeHalfFloat = 13,
-    SpvImageChannelDataTypeFloat = 14,
-    SpvImageChannelDataTypeUnormInt24 = 15,
-    SpvImageChannelDataTypeUnormInt101010_2 = 16,
-    SpvImageChannelDataTypeMax = 0x7fffffff,
+  SpvImageChannelDataTypeSnormInt8 = 0,
+  SpvImageChannelDataTypeSnormInt16 = 1,
+  SpvImageChannelDataTypeUnormInt8 = 2,
+  SpvImageChannelDataTypeUnormInt16 = 3,
+  SpvImageChannelDataTypeUnormShort565 = 4,
+  SpvImageChannelDataTypeUnormShort555 = 5,
+  SpvImageChannelDataTypeUnormInt101010 = 6,
+  SpvImageChannelDataTypeSignedInt8 = 7,
+  SpvImageChannelDataTypeSignedInt16 = 8,
+  SpvImageChannelDataTypeSignedInt32 = 9,
+  SpvImageChannelDataTypeUnsignedInt8 = 10,
+  SpvImageChannelDataTypeUnsignedInt16 = 11,
+  SpvImageChannelDataTypeUnsignedInt32 = 12,
+  SpvImageChannelDataTypeHalfFloat = 13,
+  SpvImageChannelDataTypeFloat = 14,
+  SpvImageChannelDataTypeUnormInt24 = 15,
+  SpvImageChannelDataTypeUnormInt101010_2 = 16,
+  SpvImageChannelDataTypeUnsignedIntRaw10EXT = 19,
+  SpvImageChannelDataTypeUnsignedIntRaw12EXT = 20,
+  SpvImageChannelDataTypeMax = 0x7fffffff,
 } SpvImageChannelDataType;
 
 typedef enum SpvImageOperandsShift_ {
-    SpvImageOperandsBiasShift = 0,
-    SpvImageOperandsLodShift = 1,
-    SpvImageOperandsGradShift = 2,
-    SpvImageOperandsConstOffsetShift = 3,
-    SpvImageOperandsOffsetShift = 4,
-    SpvImageOperandsConstOffsetsShift = 5,
-    SpvImageOperandsSampleShift = 6,
-    SpvImageOperandsMinLodShift = 7,
-    SpvImageOperandsMakeTexelAvailableShift = 8,
-    SpvImageOperandsMakeTexelAvailableKHRShift = 8,
-    SpvImageOperandsMakeTexelVisibleShift = 9,
-    SpvImageOperandsMakeTexelVisibleKHRShift = 9,
-    SpvImageOperandsNonPrivateTexelShift = 10,
-    SpvImageOperandsNonPrivateTexelKHRShift = 10,
-    SpvImageOperandsVolatileTexelShift = 11,
-    SpvImageOperandsVolatileTexelKHRShift = 11,
-    SpvImageOperandsSignExtendShift = 12,
-    SpvImageOperandsZeroExtendShift = 13,
-    SpvImageOperandsMax = 0x7fffffff,
+  SpvImageOperandsBiasShift = 0,
+  SpvImageOperandsLodShift = 1,
+  SpvImageOperandsGradShift = 2,
+  SpvImageOperandsConstOffsetShift = 3,
+  SpvImageOperandsOffsetShift = 4,
+  SpvImageOperandsConstOffsetsShift = 5,
+  SpvImageOperandsSampleShift = 6,
+  SpvImageOperandsMinLodShift = 7,
+  SpvImageOperandsMakeTexelAvailableShift = 8,
+  SpvImageOperandsMakeTexelAvailableKHRShift = 8,
+  SpvImageOperandsMakeTexelVisibleShift = 9,
+  SpvImageOperandsMakeTexelVisibleKHRShift = 9,
+  SpvImageOperandsNonPrivateTexelShift = 10,
+  SpvImageOperandsNonPrivateTexelKHRShift = 10,
+  SpvImageOperandsVolatileTexelShift = 11,
+  SpvImageOperandsVolatileTexelKHRShift = 11,
+  SpvImageOperandsSignExtendShift = 12,
+  SpvImageOperandsZeroExtendShift = 13,
+  SpvImageOperandsNontemporalShift = 14,
+  SpvImageOperandsOffsetsShift = 16,
+  SpvImageOperandsMax = 0x7fffffff,
 } SpvImageOperandsShift;
 
 typedef enum SpvImageOperandsMask_ {
-    SpvImageOperandsMaskNone = 0,
-    SpvImageOperandsBiasMask = 0x00000001,
-    SpvImageOperandsLodMask = 0x00000002,
-    SpvImageOperandsGradMask = 0x00000004,
-    SpvImageOperandsConstOffsetMask = 0x00000008,
-    SpvImageOperandsOffsetMask = 0x00000010,
-    SpvImageOperandsConstOffsetsMask = 0x00000020,
-    SpvImageOperandsSampleMask = 0x00000040,
-    SpvImageOperandsMinLodMask = 0x00000080,
-    SpvImageOperandsMakeTexelAvailableMask = 0x00000100,
-    SpvImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
-    SpvImageOperandsMakeTexelVisibleMask = 0x00000200,
-    SpvImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
-    SpvImageOperandsNonPrivateTexelMask = 0x00000400,
-    SpvImageOperandsNonPrivateTexelKHRMask = 0x00000400,
-    SpvImageOperandsVolatileTexelMask = 0x00000800,
-    SpvImageOperandsVolatileTexelKHRMask = 0x00000800,
-    SpvImageOperandsSignExtendMask = 0x00001000,
-    SpvImageOperandsZeroExtendMask = 0x00002000,
+  SpvImageOperandsMaskNone = 0,
+  SpvImageOperandsBiasMask = 0x00000001,
+  SpvImageOperandsLodMask = 0x00000002,
+  SpvImageOperandsGradMask = 0x00000004,
+  SpvImageOperandsConstOffsetMask = 0x00000008,
+  SpvImageOperandsOffsetMask = 0x00000010,
+  SpvImageOperandsConstOffsetsMask = 0x00000020,
+  SpvImageOperandsSampleMask = 0x00000040,
+  SpvImageOperandsMinLodMask = 0x00000080,
+  SpvImageOperandsMakeTexelAvailableMask = 0x00000100,
+  SpvImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
+  SpvImageOperandsMakeTexelVisibleMask = 0x00000200,
+  SpvImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
+  SpvImageOperandsNonPrivateTexelMask = 0x00000400,
+  SpvImageOperandsNonPrivateTexelKHRMask = 0x00000400,
+  SpvImageOperandsVolatileTexelMask = 0x00000800,
+  SpvImageOperandsVolatileTexelKHRMask = 0x00000800,
+  SpvImageOperandsSignExtendMask = 0x00001000,
+  SpvImageOperandsZeroExtendMask = 0x00002000,
+  SpvImageOperandsNontemporalMask = 0x00004000,
+  SpvImageOperandsOffsetsMask = 0x00010000,
 } SpvImageOperandsMask;
 
 typedef enum SpvFPFastMathModeShift_ {
-    SpvFPFastMathModeNotNaNShift = 0,
-    SpvFPFastMathModeNotInfShift = 1,
-    SpvFPFastMathModeNSZShift = 2,
-    SpvFPFastMathModeAllowRecipShift = 3,
-    SpvFPFastMathModeFastShift = 4,
-    SpvFPFastMathModeMax = 0x7fffffff,
+  SpvFPFastMathModeNotNaNShift = 0,
+  SpvFPFastMathModeNotInfShift = 1,
+  SpvFPFastMathModeNSZShift = 2,
+  SpvFPFastMathModeAllowRecipShift = 3,
+  SpvFPFastMathModeFastShift = 4,
+  SpvFPFastMathModeAllowContractFastINTELShift = 16,
+  SpvFPFastMathModeAllowReassocINTELShift = 17,
+  SpvFPFastMathModeMax = 0x7fffffff,
 } SpvFPFastMathModeShift;
 
 typedef enum SpvFPFastMathModeMask_ {
-    SpvFPFastMathModeMaskNone = 0,
-    SpvFPFastMathModeNotNaNMask = 0x00000001,
-    SpvFPFastMathModeNotInfMask = 0x00000002,
-    SpvFPFastMathModeNSZMask = 0x00000004,
-    SpvFPFastMathModeAllowRecipMask = 0x00000008,
-    SpvFPFastMathModeFastMask = 0x00000010,
+  SpvFPFastMathModeMaskNone = 0,
+  SpvFPFastMathModeNotNaNMask = 0x00000001,
+  SpvFPFastMathModeNotInfMask = 0x00000002,
+  SpvFPFastMathModeNSZMask = 0x00000004,
+  SpvFPFastMathModeAllowRecipMask = 0x00000008,
+  SpvFPFastMathModeFastMask = 0x00000010,
+  SpvFPFastMathModeAllowContractFastINTELMask = 0x00010000,
+  SpvFPFastMathModeAllowReassocINTELMask = 0x00020000,
 } SpvFPFastMathModeMask;
 
 typedef enum SpvFPRoundingMode_ {
-    SpvFPRoundingModeRTE = 0,
-    SpvFPRoundingModeRTZ = 1,
-    SpvFPRoundingModeRTP = 2,
-    SpvFPRoundingModeRTN = 3,
-    SpvFPRoundingModeMax = 0x7fffffff,
+  SpvFPRoundingModeRTE = 0,
+  SpvFPRoundingModeRTZ = 1,
+  SpvFPRoundingModeRTP = 2,
+  SpvFPRoundingModeRTN = 3,
+  SpvFPRoundingModeMax = 0x7fffffff,
 } SpvFPRoundingMode;
 
 typedef enum SpvLinkageType_ {
-    SpvLinkageTypeExport = 0,
-    SpvLinkageTypeImport = 1,
-    SpvLinkageTypeMax = 0x7fffffff,
+  SpvLinkageTypeExport = 0,
+  SpvLinkageTypeImport = 1,
+  SpvLinkageTypeLinkOnceODR = 2,
+  SpvLinkageTypeMax = 0x7fffffff,
 } SpvLinkageType;
 
 typedef enum SpvAccessQualifier_ {
-    SpvAccessQualifierReadOnly = 0,
-    SpvAccessQualifierWriteOnly = 1,
-    SpvAccessQualifierReadWrite = 2,
-    SpvAccessQualifierMax = 0x7fffffff,
+  SpvAccessQualifierReadOnly = 0,
+  SpvAccessQualifierWriteOnly = 1,
+  SpvAccessQualifierReadWrite = 2,
+  SpvAccessQualifierMax = 0x7fffffff,
 } SpvAccessQualifier;
 
 typedef enum SpvFunctionParameterAttribute_ {
-    SpvFunctionParameterAttributeZext = 0,
-    SpvFunctionParameterAttributeSext = 1,
-    SpvFunctionParameterAttributeByVal = 2,
-    SpvFunctionParameterAttributeSret = 3,
-    SpvFunctionParameterAttributeNoAlias = 4,
-    SpvFunctionParameterAttributeNoCapture = 5,
-    SpvFunctionParameterAttributeNoWrite = 6,
-    SpvFunctionParameterAttributeNoReadWrite = 7,
-    SpvFunctionParameterAttributeMax = 0x7fffffff,
+  SpvFunctionParameterAttributeZext = 0,
+  SpvFunctionParameterAttributeSext = 1,
+  SpvFunctionParameterAttributeByVal = 2,
+  SpvFunctionParameterAttributeSret = 3,
+  SpvFunctionParameterAttributeNoAlias = 4,
+  SpvFunctionParameterAttributeNoCapture = 5,
+  SpvFunctionParameterAttributeNoWrite = 6,
+  SpvFunctionParameterAttributeNoReadWrite = 7,
+  SpvFunctionParameterAttributeRuntimeAlignedINTEL = 5940,
+  SpvFunctionParameterAttributeMax = 0x7fffffff,
 } SpvFunctionParameterAttribute;
 
 typedef enum SpvDecoration_ {
-    SpvDecorationRelaxedPrecision = 0,
-    SpvDecorationSpecId = 1,
-    SpvDecorationBlock = 2,
-    SpvDecorationBufferBlock = 3,
-    SpvDecorationRowMajor = 4,
-    SpvDecorationColMajor = 5,
-    SpvDecorationArrayStride = 6,
-    SpvDecorationMatrixStride = 7,
-    SpvDecorationGLSLShared = 8,
-    SpvDecorationGLSLPacked = 9,
-    SpvDecorationCPacked = 10,
-    SpvDecorationBuiltIn = 11,
-    SpvDecorationNoPerspective = 13,
-    SpvDecorationFlat = 14,
-    SpvDecorationPatch = 15,
-    SpvDecorationCentroid = 16,
-    SpvDecorationSample = 17,
-    SpvDecorationInvariant = 18,
-    SpvDecorationRestrict = 19,
-    SpvDecorationAliased = 20,
-    SpvDecorationVolatile = 21,
-    SpvDecorationConstant = 22,
-    SpvDecorationCoherent = 23,
-    SpvDecorationNonWritable = 24,
-    SpvDecorationNonReadable = 25,
-    SpvDecorationUniform = 26,
-    SpvDecorationUniformId = 27,
-    SpvDecorationSaturatedConversion = 28,
-    SpvDecorationStream = 29,
-    SpvDecorationLocation = 30,
-    SpvDecorationComponent = 31,
-    SpvDecorationIndex = 32,
-    SpvDecorationBinding = 33,
-    SpvDecorationDescriptorSet = 34,
-    SpvDecorationOffset = 35,
-    SpvDecorationXfbBuffer = 36,
-    SpvDecorationXfbStride = 37,
-    SpvDecorationFuncParamAttr = 38,
-    SpvDecorationFPRoundingMode = 39,
-    SpvDecorationFPFastMathMode = 40,
-    SpvDecorationLinkageAttributes = 41,
-    SpvDecorationNoContraction = 42,
-    SpvDecorationInputAttachmentIndex = 43,
-    SpvDecorationAlignment = 44,
-    SpvDecorationMaxByteOffset = 45,
-    SpvDecorationAlignmentId = 46,
-    SpvDecorationMaxByteOffsetId = 47,
-    SpvDecorationNoSignedWrap = 4469,
-    SpvDecorationNoUnsignedWrap = 4470,
-    SpvDecorationExplicitInterpAMD = 4999,
-    SpvDecorationOverrideCoverageNV = 5248,
-    SpvDecorationPassthroughNV = 5250,
-    SpvDecorationViewportRelativeNV = 5252,
-    SpvDecorationSecondaryViewportRelativeNV = 5256,
-    SpvDecorationPerPrimitiveNV = 5271,
-    SpvDecorationPerViewNV = 5272,
-    SpvDecorationPerTaskNV = 5273,
-    SpvDecorationPerVertexNV = 5285,
-    SpvDecorationNonUniform = 5300,
-    SpvDecorationNonUniformEXT = 5300,
-    SpvDecorationRestrictPointer = 5355,
-    SpvDecorationRestrictPointerEXT = 5355,
-    SpvDecorationAliasedPointer = 5356,
-    SpvDecorationAliasedPointerEXT = 5356,
-    SpvDecorationReferencedIndirectlyINTEL = 5602,
-    SpvDecorationCounterBuffer = 5634,
-    SpvDecorationHlslCounterBufferGOOGLE = 5634,
-    SpvDecorationHlslSemanticGOOGLE = 5635,
-    SpvDecorationUserSemantic = 5635,
-    SpvDecorationUserTypeGOOGLE = 5636,
-    SpvDecorationRegisterINTEL = 5825,
-    SpvDecorationMemoryINTEL = 5826,
-    SpvDecorationNumbanksINTEL = 5827,
-    SpvDecorationBankwidthINTEL = 5828,
-    SpvDecorationMaxPrivateCopiesINTEL = 5829,
-    SpvDecorationSinglepumpINTEL = 5830,
-    SpvDecorationDoublepumpINTEL = 5831,
-    SpvDecorationMaxReplicatesINTEL = 5832,
-    SpvDecorationSimpleDualPortINTEL = 5833,
-    SpvDecorationMergeINTEL = 5834,
-    SpvDecorationBankBitsINTEL = 5835,
-    SpvDecorationForcePow2DepthINTEL = 5836,
-    SpvDecorationMax = 0x7fffffff,
+  SpvDecorationRelaxedPrecision = 0,
+  SpvDecorationSpecId = 1,
+  SpvDecorationBlock = 2,
+  SpvDecorationBufferBlock = 3,
+  SpvDecorationRowMajor = 4,
+  SpvDecorationColMajor = 5,
+  SpvDecorationArrayStride = 6,
+  SpvDecorationMatrixStride = 7,
+  SpvDecorationGLSLShared = 8,
+  SpvDecorationGLSLPacked = 9,
+  SpvDecorationCPacked = 10,
+  SpvDecorationBuiltIn = 11,
+  SpvDecorationNoPerspective = 13,
+  SpvDecorationFlat = 14,
+  SpvDecorationPatch = 15,
+  SpvDecorationCentroid = 16,
+  SpvDecorationSample = 17,
+  SpvDecorationInvariant = 18,
+  SpvDecorationRestrict = 19,
+  SpvDecorationAliased = 20,
+  SpvDecorationVolatile = 21,
+  SpvDecorationConstant = 22,
+  SpvDecorationCoherent = 23,
+  SpvDecorationNonWritable = 24,
+  SpvDecorationNonReadable = 25,
+  SpvDecorationUniform = 26,
+  SpvDecorationUniformId = 27,
+  SpvDecorationSaturatedConversion = 28,
+  SpvDecorationStream = 29,
+  SpvDecorationLocation = 30,
+  SpvDecorationComponent = 31,
+  SpvDecorationIndex = 32,
+  SpvDecorationBinding = 33,
+  SpvDecorationDescriptorSet = 34,
+  SpvDecorationOffset = 35,
+  SpvDecorationXfbBuffer = 36,
+  SpvDecorationXfbStride = 37,
+  SpvDecorationFuncParamAttr = 38,
+  SpvDecorationFPRoundingMode = 39,
+  SpvDecorationFPFastMathMode = 40,
+  SpvDecorationLinkageAttributes = 41,
+  SpvDecorationNoContraction = 42,
+  SpvDecorationInputAttachmentIndex = 43,
+  SpvDecorationAlignment = 44,
+  SpvDecorationMaxByteOffset = 45,
+  SpvDecorationAlignmentId = 46,
+  SpvDecorationMaxByteOffsetId = 47,
+  SpvDecorationNoSignedWrap = 4469,
+  SpvDecorationNoUnsignedWrap = 4470,
+  SpvDecorationWeightTextureQCOM = 4487,
+  SpvDecorationBlockMatchTextureQCOM = 4488,
+  SpvDecorationExplicitInterpAMD = 4999,
+  SpvDecorationOverrideCoverageNV = 5248,
+  SpvDecorationPassthroughNV = 5250,
+  SpvDecorationViewportRelativeNV = 5252,
+  SpvDecorationSecondaryViewportRelativeNV = 5256,
+  SpvDecorationPerPrimitiveEXT = 5271,
+  SpvDecorationPerPrimitiveNV = 5271,
+  SpvDecorationPerViewNV = 5272,
+  SpvDecorationPerTaskNV = 5273,
+  SpvDecorationPerVertexKHR = 5285,
+  SpvDecorationPerVertexNV = 5285,
+  SpvDecorationNonUniform = 5300,
+  SpvDecorationNonUniformEXT = 5300,
+  SpvDecorationRestrictPointer = 5355,
+  SpvDecorationRestrictPointerEXT = 5355,
+  SpvDecorationAliasedPointer = 5356,
+  SpvDecorationAliasedPointerEXT = 5356,
+  SpvDecorationHitObjectShaderRecordBufferNV = 5386,
+  SpvDecorationBindlessSamplerNV = 5398,
+  SpvDecorationBindlessImageNV = 5399,
+  SpvDecorationBoundSamplerNV = 5400,
+  SpvDecorationBoundImageNV = 5401,
+  SpvDecorationSIMTCallINTEL = 5599,
+  SpvDecorationReferencedIndirectlyINTEL = 5602,
+  SpvDecorationClobberINTEL = 5607,
+  SpvDecorationSideEffectsINTEL = 5608,
+  SpvDecorationVectorComputeVariableINTEL = 5624,
+  SpvDecorationFuncParamIOKindINTEL = 5625,
+  SpvDecorationVectorComputeFunctionINTEL = 5626,
+  SpvDecorationStackCallINTEL = 5627,
+  SpvDecorationGlobalVariableOffsetINTEL = 5628,
+  SpvDecorationCounterBuffer = 5634,
+  SpvDecorationHlslCounterBufferGOOGLE = 5634,
+  SpvDecorationHlslSemanticGOOGLE = 5635,
+  SpvDecorationUserSemantic = 5635,
+  SpvDecorationUserTypeGOOGLE = 5636,
+  SpvDecorationFunctionRoundingModeINTEL = 5822,
+  SpvDecorationFunctionDenormModeINTEL = 5823,
+  SpvDecorationRegisterINTEL = 5825,
+  SpvDecorationMemoryINTEL = 5826,
+  SpvDecorationNumbanksINTEL = 5827,
+  SpvDecorationBankwidthINTEL = 5828,
+  SpvDecorationMaxPrivateCopiesINTEL = 5829,
+  SpvDecorationSinglepumpINTEL = 5830,
+  SpvDecorationDoublepumpINTEL = 5831,
+  SpvDecorationMaxReplicatesINTEL = 5832,
+  SpvDecorationSimpleDualPortINTEL = 5833,
+  SpvDecorationMergeINTEL = 5834,
+  SpvDecorationBankBitsINTEL = 5835,
+  SpvDecorationForcePow2DepthINTEL = 5836,
+  SpvDecorationBurstCoalesceINTEL = 5899,
+  SpvDecorationCacheSizeINTEL = 5900,
+  SpvDecorationDontStaticallyCoalesceINTEL = 5901,
+  SpvDecorationPrefetchINTEL = 5902,
+  SpvDecorationStallEnableINTEL = 5905,
+  SpvDecorationFuseLoopsInFunctionINTEL = 5907,
+  SpvDecorationMathOpDSPModeINTEL = 5909,
+  SpvDecorationAliasScopeINTEL = 5914,
+  SpvDecorationNoAliasINTEL = 5915,
+  SpvDecorationInitiationIntervalINTEL = 5917,
+  SpvDecorationMaxConcurrencyINTEL = 5918,
+  SpvDecorationPipelineEnableINTEL = 5919,
+  SpvDecorationBufferLocationINTEL = 5921,
+  SpvDecorationIOPipeStorageINTEL = 5944,
+  SpvDecorationFunctionFloatingPointModeINTEL = 6080,
+  SpvDecorationSingleElementVectorINTEL = 6085,
+  SpvDecorationVectorComputeCallableFunctionINTEL = 6087,
+  SpvDecorationMediaBlockIOINTEL = 6140,
+  SpvDecorationLatencyControlLabelINTEL = 6172,
+  SpvDecorationLatencyControlConstraintINTEL = 6173,
+  SpvDecorationConduitKernelArgumentINTEL = 6175,
+  SpvDecorationRegisterMapKernelArgumentINTEL = 6176,
+  SpvDecorationMMHostInterfaceAddressWidthINTEL = 6177,
+  SpvDecorationMMHostInterfaceDataWidthINTEL = 6178,
+  SpvDecorationMMHostInterfaceLatencyINTEL = 6179,
+  SpvDecorationMMHostInterfaceReadWriteModeINTEL = 6180,
+  SpvDecorationMMHostInterfaceMaxBurstINTEL = 6181,
+  SpvDecorationMMHostInterfaceWaitRequestINTEL = 6182,
+  SpvDecorationStableKernelArgumentINTEL = 6183,
+  SpvDecorationMax = 0x7fffffff,
 } SpvDecoration;
 
 typedef enum SpvBuiltIn_ {
-    SpvBuiltInPosition = 0,
-    SpvBuiltInPointSize = 1,
-    SpvBuiltInClipDistance = 3,
-    SpvBuiltInCullDistance = 4,
-    SpvBuiltInVertexId = 5,
-    SpvBuiltInInstanceId = 6,
-    SpvBuiltInPrimitiveId = 7,
-    SpvBuiltInInvocationId = 8,
-    SpvBuiltInLayer = 9,
-    SpvBuiltInViewportIndex = 10,
-    SpvBuiltInTessLevelOuter = 11,
-    SpvBuiltInTessLevelInner = 12,
-    SpvBuiltInTessCoord = 13,
-    SpvBuiltInPatchVertices = 14,
-    SpvBuiltInFragCoord = 15,
-    SpvBuiltInPointCoord = 16,
-    SpvBuiltInFrontFacing = 17,
-    SpvBuiltInSampleId = 18,
-    SpvBuiltInSamplePosition = 19,
-    SpvBuiltInSampleMask = 20,
-    SpvBuiltInFragDepth = 22,
-    SpvBuiltInHelperInvocation = 23,
-    SpvBuiltInNumWorkgroups = 24,
-    SpvBuiltInWorkgroupSize = 25,
-    SpvBuiltInWorkgroupId = 26,
-    SpvBuiltInLocalInvocationId = 27,
-    SpvBuiltInGlobalInvocationId = 28,
-    SpvBuiltInLocalInvocationIndex = 29,
-    SpvBuiltInWorkDim = 30,
-    SpvBuiltInGlobalSize = 31,
-    SpvBuiltInEnqueuedWorkgroupSize = 32,
-    SpvBuiltInGlobalOffset = 33,
-    SpvBuiltInGlobalLinearId = 34,
-    SpvBuiltInSubgroupSize = 36,
-    SpvBuiltInSubgroupMaxSize = 37,
-    SpvBuiltInNumSubgroups = 38,
-    SpvBuiltInNumEnqueuedSubgroups = 39,
-    SpvBuiltInSubgroupId = 40,
-    SpvBuiltInSubgroupLocalInvocationId = 41,
-    SpvBuiltInVertexIndex = 42,
-    SpvBuiltInInstanceIndex = 43,
-    SpvBuiltInSubgroupEqMask = 4416,
-    SpvBuiltInSubgroupEqMaskKHR = 4416,
-    SpvBuiltInSubgroupGeMask = 4417,
-    SpvBuiltInSubgroupGeMaskKHR = 4417,
-    SpvBuiltInSubgroupGtMask = 4418,
-    SpvBuiltInSubgroupGtMaskKHR = 4418,
-    SpvBuiltInSubgroupLeMask = 4419,
-    SpvBuiltInSubgroupLeMaskKHR = 4419,
-    SpvBuiltInSubgroupLtMask = 4420,
-    SpvBuiltInSubgroupLtMaskKHR = 4420,
-    SpvBuiltInBaseVertex = 4424,
-    SpvBuiltInBaseInstance = 4425,
-    SpvBuiltInDrawIndex = 4426,
-    SpvBuiltInPrimitiveShadingRateKHR = 4432,
-    SpvBuiltInDeviceIndex = 4438,
-    SpvBuiltInViewIndex = 4440,
-    SpvBuiltInShadingRateKHR = 4444,
-    SpvBuiltInBaryCoordNoPerspAMD = 4992,
-    SpvBuiltInBaryCoordNoPerspCentroidAMD = 4993,
-    SpvBuiltInBaryCoordNoPerspSampleAMD = 4994,
-    SpvBuiltInBaryCoordSmoothAMD = 4995,
-    SpvBuiltInBaryCoordSmoothCentroidAMD = 4996,
-    SpvBuiltInBaryCoordSmoothSampleAMD = 4997,
-    SpvBuiltInBaryCoordPullModelAMD = 4998,
-    SpvBuiltInFragStencilRefEXT = 5014,
-    SpvBuiltInViewportMaskNV = 5253,
-    SpvBuiltInSecondaryPositionNV = 5257,
-    SpvBuiltInSecondaryViewportMaskNV = 5258,
-    SpvBuiltInPositionPerViewNV = 5261,
-    SpvBuiltInViewportMaskPerViewNV = 5262,
-    SpvBuiltInFullyCoveredEXT = 5264,
-    SpvBuiltInTaskCountNV = 5274,
-    SpvBuiltInPrimitiveCountNV = 5275,
-    SpvBuiltInPrimitiveIndicesNV = 5276,
-    SpvBuiltInClipDistancePerViewNV = 5277,
-    SpvBuiltInCullDistancePerViewNV = 5278,
-    SpvBuiltInLayerPerViewNV = 5279,
-    SpvBuiltInMeshViewCountNV = 5280,
-    SpvBuiltInMeshViewIndicesNV = 5281,
-    SpvBuiltInBaryCoordNV = 5286,
-    SpvBuiltInBaryCoordNoPerspNV = 5287,
-    SpvBuiltInFragSizeEXT = 5292,
-    SpvBuiltInFragmentSizeNV = 5292,
-    SpvBuiltInFragInvocationCountEXT = 5293,
-    SpvBuiltInInvocationsPerPixelNV = 5293,
-    SpvBuiltInLaunchIdKHR = 5319,
-    SpvBuiltInLaunchIdNV = 5319,
-    SpvBuiltInLaunchSizeKHR = 5320,
-    SpvBuiltInLaunchSizeNV = 5320,
-    SpvBuiltInWorldRayOriginKHR = 5321,
-    SpvBuiltInWorldRayOriginNV = 5321,
-    SpvBuiltInWorldRayDirectionKHR = 5322,
-    SpvBuiltInWorldRayDirectionNV = 5322,
-    SpvBuiltInObjectRayOriginKHR = 5323,
-    SpvBuiltInObjectRayOriginNV = 5323,
-    SpvBuiltInObjectRayDirectionKHR = 5324,
-    SpvBuiltInObjectRayDirectionNV = 5324,
-    SpvBuiltInRayTminKHR = 5325,
-    SpvBuiltInRayTminNV = 5325,
-    SpvBuiltInRayTmaxKHR = 5326,
-    SpvBuiltInRayTmaxNV = 5326,
-    SpvBuiltInInstanceCustomIndexKHR = 5327,
-    SpvBuiltInInstanceCustomIndexNV = 5327,
-    SpvBuiltInObjectToWorldKHR = 5330,
-    SpvBuiltInObjectToWorldNV = 5330,
-    SpvBuiltInWorldToObjectKHR = 5331,
-    SpvBuiltInWorldToObjectNV = 5331,
-    SpvBuiltInHitTNV = 5332,
-    SpvBuiltInHitKindKHR = 5333,
-    SpvBuiltInHitKindNV = 5333,
-    SpvBuiltInIncomingRayFlagsKHR = 5351,
-    SpvBuiltInIncomingRayFlagsNV = 5351,
-    SpvBuiltInRayGeometryIndexKHR = 5352,
-    SpvBuiltInWarpsPerSMNV = 5374,
-    SpvBuiltInSMCountNV = 5375,
-    SpvBuiltInWarpIDNV = 5376,
-    SpvBuiltInSMIDNV = 5377,
-    SpvBuiltInMax = 0x7fffffff,
+  SpvBuiltInPosition = 0,
+  SpvBuiltInPointSize = 1,
+  SpvBuiltInClipDistance = 3,
+  SpvBuiltInCullDistance = 4,
+  SpvBuiltInVertexId = 5,
+  SpvBuiltInInstanceId = 6,
+  SpvBuiltInPrimitiveId = 7,
+  SpvBuiltInInvocationId = 8,
+  SpvBuiltInLayer = 9,
+  SpvBuiltInViewportIndex = 10,
+  SpvBuiltInTessLevelOuter = 11,
+  SpvBuiltInTessLevelInner = 12,
+  SpvBuiltInTessCoord = 13,
+  SpvBuiltInPatchVertices = 14,
+  SpvBuiltInFragCoord = 15,
+  SpvBuiltInPointCoord = 16,
+  SpvBuiltInFrontFacing = 17,
+  SpvBuiltInSampleId = 18,
+  SpvBuiltInSamplePosition = 19,
+  SpvBuiltInSampleMask = 20,
+  SpvBuiltInFragDepth = 22,
+  SpvBuiltInHelperInvocation = 23,
+  SpvBuiltInNumWorkgroups = 24,
+  SpvBuiltInWorkgroupSize = 25,
+  SpvBuiltInWorkgroupId = 26,
+  SpvBuiltInLocalInvocationId = 27,
+  SpvBuiltInGlobalInvocationId = 28,
+  SpvBuiltInLocalInvocationIndex = 29,
+  SpvBuiltInWorkDim = 30,
+  SpvBuiltInGlobalSize = 31,
+  SpvBuiltInEnqueuedWorkgroupSize = 32,
+  SpvBuiltInGlobalOffset = 33,
+  SpvBuiltInGlobalLinearId = 34,
+  SpvBuiltInSubgroupSize = 36,
+  SpvBuiltInSubgroupMaxSize = 37,
+  SpvBuiltInNumSubgroups = 38,
+  SpvBuiltInNumEnqueuedSubgroups = 39,
+  SpvBuiltInSubgroupId = 40,
+  SpvBuiltInSubgroupLocalInvocationId = 41,
+  SpvBuiltInVertexIndex = 42,
+  SpvBuiltInInstanceIndex = 43,
+  SpvBuiltInCoreIDARM = 4160,
+  SpvBuiltInCoreCountARM = 4161,
+  SpvBuiltInCoreMaxIDARM = 4162,
+  SpvBuiltInWarpIDARM = 4163,
+  SpvBuiltInWarpMaxIDARM = 4164,
+  SpvBuiltInSubgroupEqMask = 4416,
+  SpvBuiltInSubgroupEqMaskKHR = 4416,
+  SpvBuiltInSubgroupGeMask = 4417,
+  SpvBuiltInSubgroupGeMaskKHR = 4417,
+  SpvBuiltInSubgroupGtMask = 4418,
+  SpvBuiltInSubgroupGtMaskKHR = 4418,
+  SpvBuiltInSubgroupLeMask = 4419,
+  SpvBuiltInSubgroupLeMaskKHR = 4419,
+  SpvBuiltInSubgroupLtMask = 4420,
+  SpvBuiltInSubgroupLtMaskKHR = 4420,
+  SpvBuiltInBaseVertex = 4424,
+  SpvBuiltInBaseInstance = 4425,
+  SpvBuiltInDrawIndex = 4426,
+  SpvBuiltInPrimitiveShadingRateKHR = 4432,
+  SpvBuiltInDeviceIndex = 4438,
+  SpvBuiltInViewIndex = 4440,
+  SpvBuiltInShadingRateKHR = 4444,
+  SpvBuiltInBaryCoordNoPerspAMD = 4992,
+  SpvBuiltInBaryCoordNoPerspCentroidAMD = 4993,
+  SpvBuiltInBaryCoordNoPerspSampleAMD = 4994,
+  SpvBuiltInBaryCoordSmoothAMD = 4995,
+  SpvBuiltInBaryCoordSmoothCentroidAMD = 4996,
+  SpvBuiltInBaryCoordSmoothSampleAMD = 4997,
+  SpvBuiltInBaryCoordPullModelAMD = 4998,
+  SpvBuiltInFragStencilRefEXT = 5014,
+  SpvBuiltInViewportMaskNV = 5253,
+  SpvBuiltInSecondaryPositionNV = 5257,
+  SpvBuiltInSecondaryViewportMaskNV = 5258,
+  SpvBuiltInPositionPerViewNV = 5261,
+  SpvBuiltInViewportMaskPerViewNV = 5262,
+  SpvBuiltInFullyCoveredEXT = 5264,
+  SpvBuiltInTaskCountNV = 5274,
+  SpvBuiltInPrimitiveCountNV = 5275,
+  SpvBuiltInPrimitiveIndicesNV = 5276,
+  SpvBuiltInClipDistancePerViewNV = 5277,
+  SpvBuiltInCullDistancePerViewNV = 5278,
+  SpvBuiltInLayerPerViewNV = 5279,
+  SpvBuiltInMeshViewCountNV = 5280,
+  SpvBuiltInMeshViewIndicesNV = 5281,
+  SpvBuiltInBaryCoordKHR = 5286,
+  SpvBuiltInBaryCoordNV = 5286,
+  SpvBuiltInBaryCoordNoPerspKHR = 5287,
+  SpvBuiltInBaryCoordNoPerspNV = 5287,
+  SpvBuiltInFragSizeEXT = 5292,
+  SpvBuiltInFragmentSizeNV = 5292,
+  SpvBuiltInFragInvocationCountEXT = 5293,
+  SpvBuiltInInvocationsPerPixelNV = 5293,
+  SpvBuiltInPrimitivePointIndicesEXT = 5294,
+  SpvBuiltInPrimitiveLineIndicesEXT = 5295,
+  SpvBuiltInPrimitiveTriangleIndicesEXT = 5296,
+  SpvBuiltInCullPrimitiveEXT = 5299,
+  SpvBuiltInLaunchIdKHR = 5319,
+  SpvBuiltInLaunchIdNV = 5319,
+  SpvBuiltInLaunchSizeKHR = 5320,
+  SpvBuiltInLaunchSizeNV = 5320,
+  SpvBuiltInWorldRayOriginKHR = 5321,
+  SpvBuiltInWorldRayOriginNV = 5321,
+  SpvBuiltInWorldRayDirectionKHR = 5322,
+  SpvBuiltInWorldRayDirectionNV = 5322,
+  SpvBuiltInObjectRayOriginKHR = 5323,
+  SpvBuiltInObjectRayOriginNV = 5323,
+  SpvBuiltInObjectRayDirectionKHR = 5324,
+  SpvBuiltInObjectRayDirectionNV = 5324,
+  SpvBuiltInRayTminKHR = 5325,
+  SpvBuiltInRayTminNV = 5325,
+  SpvBuiltInRayTmaxKHR = 5326,
+  SpvBuiltInRayTmaxNV = 5326,
+  SpvBuiltInInstanceCustomIndexKHR = 5327,
+  SpvBuiltInInstanceCustomIndexNV = 5327,
+  SpvBuiltInObjectToWorldKHR = 5330,
+  SpvBuiltInObjectToWorldNV = 5330,
+  SpvBuiltInWorldToObjectKHR = 5331,
+  SpvBuiltInWorldToObjectNV = 5331,
+  SpvBuiltInHitTNV = 5332,
+  SpvBuiltInHitKindKHR = 5333,
+  SpvBuiltInHitKindNV = 5333,
+  SpvBuiltInCurrentRayTimeNV = 5334,
+  SpvBuiltInHitTriangleVertexPositionsKHR = 5335,
+  SpvBuiltInIncomingRayFlagsKHR = 5351,
+  SpvBuiltInIncomingRayFlagsNV = 5351,
+  SpvBuiltInRayGeometryIndexKHR = 5352,
+  SpvBuiltInWarpsPerSMNV = 5374,
+  SpvBuiltInSMCountNV = 5375,
+  SpvBuiltInWarpIDNV = 5376,
+  SpvBuiltInSMIDNV = 5377,
+  SpvBuiltInCullMaskKHR = 6021,
+  SpvBuiltInMax = 0x7fffffff,
 } SpvBuiltIn;
 
 typedef enum SpvSelectionControlShift_ {
-    SpvSelectionControlFlattenShift = 0,
-    SpvSelectionControlDontFlattenShift = 1,
-    SpvSelectionControlMax = 0x7fffffff,
+  SpvSelectionControlFlattenShift = 0,
+  SpvSelectionControlDontFlattenShift = 1,
+  SpvSelectionControlMax = 0x7fffffff,
 } SpvSelectionControlShift;
 
 typedef enum SpvSelectionControlMask_ {
-    SpvSelectionControlMaskNone = 0,
-    SpvSelectionControlFlattenMask = 0x00000001,
-    SpvSelectionControlDontFlattenMask = 0x00000002,
+  SpvSelectionControlMaskNone = 0,
+  SpvSelectionControlFlattenMask = 0x00000001,
+  SpvSelectionControlDontFlattenMask = 0x00000002,
 } SpvSelectionControlMask;
 
 typedef enum SpvLoopControlShift_ {
-    SpvLoopControlUnrollShift = 0,
-    SpvLoopControlDontUnrollShift = 1,
-    SpvLoopControlDependencyInfiniteShift = 2,
-    SpvLoopControlDependencyLengthShift = 3,
-    SpvLoopControlMinIterationsShift = 4,
-    SpvLoopControlMaxIterationsShift = 5,
-    SpvLoopControlIterationMultipleShift = 6,
-    SpvLoopControlPeelCountShift = 7,
-    SpvLoopControlPartialCountShift = 8,
-    SpvLoopControlInitiationIntervalINTELShift = 16,
-    SpvLoopControlMaxConcurrencyINTELShift = 17,
-    SpvLoopControlDependencyArrayINTELShift = 18,
-    SpvLoopControlPipelineEnableINTELShift = 19,
-    SpvLoopControlLoopCoalesceINTELShift = 20,
-    SpvLoopControlMaxInterleavingINTELShift = 21,
-    SpvLoopControlSpeculatedIterationsINTELShift = 22,
-    SpvLoopControlMax = 0x7fffffff,
+  SpvLoopControlUnrollShift = 0,
+  SpvLoopControlDontUnrollShift = 1,
+  SpvLoopControlDependencyInfiniteShift = 2,
+  SpvLoopControlDependencyLengthShift = 3,
+  SpvLoopControlMinIterationsShift = 4,
+  SpvLoopControlMaxIterationsShift = 5,
+  SpvLoopControlIterationMultipleShift = 6,
+  SpvLoopControlPeelCountShift = 7,
+  SpvLoopControlPartialCountShift = 8,
+  SpvLoopControlInitiationIntervalINTELShift = 16,
+  SpvLoopControlMaxConcurrencyINTELShift = 17,
+  SpvLoopControlDependencyArrayINTELShift = 18,
+  SpvLoopControlPipelineEnableINTELShift = 19,
+  SpvLoopControlLoopCoalesceINTELShift = 20,
+  SpvLoopControlMaxInterleavingINTELShift = 21,
+  SpvLoopControlSpeculatedIterationsINTELShift = 22,
+  SpvLoopControlNoFusionINTELShift = 23,
+  SpvLoopControlLoopCountINTELShift = 24,
+  SpvLoopControlMaxReinvocationDelayINTELShift = 25,
+  SpvLoopControlMax = 0x7fffffff,
 } SpvLoopControlShift;
 
 typedef enum SpvLoopControlMask_ {
-    SpvLoopControlMaskNone = 0,
-    SpvLoopControlUnrollMask = 0x00000001,
-    SpvLoopControlDontUnrollMask = 0x00000002,
-    SpvLoopControlDependencyInfiniteMask = 0x00000004,
-    SpvLoopControlDependencyLengthMask = 0x00000008,
-    SpvLoopControlMinIterationsMask = 0x00000010,
-    SpvLoopControlMaxIterationsMask = 0x00000020,
-    SpvLoopControlIterationMultipleMask = 0x00000040,
-    SpvLoopControlPeelCountMask = 0x00000080,
-    SpvLoopControlPartialCountMask = 0x00000100,
-    SpvLoopControlInitiationIntervalINTELMask = 0x00010000,
-    SpvLoopControlMaxConcurrencyINTELMask = 0x00020000,
-    SpvLoopControlDependencyArrayINTELMask = 0x00040000,
-    SpvLoopControlPipelineEnableINTELMask = 0x00080000,
-    SpvLoopControlLoopCoalesceINTELMask = 0x00100000,
-    SpvLoopControlMaxInterleavingINTELMask = 0x00200000,
-    SpvLoopControlSpeculatedIterationsINTELMask = 0x00400000,
+  SpvLoopControlMaskNone = 0,
+  SpvLoopControlUnrollMask = 0x00000001,
+  SpvLoopControlDontUnrollMask = 0x00000002,
+  SpvLoopControlDependencyInfiniteMask = 0x00000004,
+  SpvLoopControlDependencyLengthMask = 0x00000008,
+  SpvLoopControlMinIterationsMask = 0x00000010,
+  SpvLoopControlMaxIterationsMask = 0x00000020,
+  SpvLoopControlIterationMultipleMask = 0x00000040,
+  SpvLoopControlPeelCountMask = 0x00000080,
+  SpvLoopControlPartialCountMask = 0x00000100,
+  SpvLoopControlInitiationIntervalINTELMask = 0x00010000,
+  SpvLoopControlMaxConcurrencyINTELMask = 0x00020000,
+  SpvLoopControlDependencyArrayINTELMask = 0x00040000,
+  SpvLoopControlPipelineEnableINTELMask = 0x00080000,
+  SpvLoopControlLoopCoalesceINTELMask = 0x00100000,
+  SpvLoopControlMaxInterleavingINTELMask = 0x00200000,
+  SpvLoopControlSpeculatedIterationsINTELMask = 0x00400000,
+  SpvLoopControlNoFusionINTELMask = 0x00800000,
+  SpvLoopControlLoopCountINTELMask = 0x01000000,
+  SpvLoopControlMaxReinvocationDelayINTELMask = 0x02000000,
 } SpvLoopControlMask;
 
 typedef enum SpvFunctionControlShift_ {
-    SpvFunctionControlInlineShift = 0,
-    SpvFunctionControlDontInlineShift = 1,
-    SpvFunctionControlPureShift = 2,
-    SpvFunctionControlConstShift = 3,
-    SpvFunctionControlMax = 0x7fffffff,
+  SpvFunctionControlInlineShift = 0,
+  SpvFunctionControlDontInlineShift = 1,
+  SpvFunctionControlPureShift = 2,
+  SpvFunctionControlConstShift = 3,
+  SpvFunctionControlOptNoneINTELShift = 16,
+  SpvFunctionControlMax = 0x7fffffff,
 } SpvFunctionControlShift;
 
 typedef enum SpvFunctionControlMask_ {
-    SpvFunctionControlMaskNone = 0,
-    SpvFunctionControlInlineMask = 0x00000001,
-    SpvFunctionControlDontInlineMask = 0x00000002,
-    SpvFunctionControlPureMask = 0x00000004,
-    SpvFunctionControlConstMask = 0x00000008,
+  SpvFunctionControlMaskNone = 0,
+  SpvFunctionControlInlineMask = 0x00000001,
+  SpvFunctionControlDontInlineMask = 0x00000002,
+  SpvFunctionControlPureMask = 0x00000004,
+  SpvFunctionControlConstMask = 0x00000008,
+  SpvFunctionControlOptNoneINTELMask = 0x00010000,
 } SpvFunctionControlMask;
 
 typedef enum SpvMemorySemanticsShift_ {
-    SpvMemorySemanticsAcquireShift = 1,
-    SpvMemorySemanticsReleaseShift = 2,
-    SpvMemorySemanticsAcquireReleaseShift = 3,
-    SpvMemorySemanticsSequentiallyConsistentShift = 4,
-    SpvMemorySemanticsUniformMemoryShift = 6,
-    SpvMemorySemanticsSubgroupMemoryShift = 7,
-    SpvMemorySemanticsWorkgroupMemoryShift = 8,
-    SpvMemorySemanticsCrossWorkgroupMemoryShift = 9,
-    SpvMemorySemanticsAtomicCounterMemoryShift = 10,
-    SpvMemorySemanticsImageMemoryShift = 11,
-    SpvMemorySemanticsOutputMemoryShift = 12,
-    SpvMemorySemanticsOutputMemoryKHRShift = 12,
-    SpvMemorySemanticsMakeAvailableShift = 13,
-    SpvMemorySemanticsMakeAvailableKHRShift = 13,
-    SpvMemorySemanticsMakeVisibleShift = 14,
-    SpvMemorySemanticsMakeVisibleKHRShift = 14,
-    SpvMemorySemanticsVolatileShift = 15,
-    SpvMemorySemanticsMax = 0x7fffffff,
+  SpvMemorySemanticsAcquireShift = 1,
+  SpvMemorySemanticsReleaseShift = 2,
+  SpvMemorySemanticsAcquireReleaseShift = 3,
+  SpvMemorySemanticsSequentiallyConsistentShift = 4,
+  SpvMemorySemanticsUniformMemoryShift = 6,
+  SpvMemorySemanticsSubgroupMemoryShift = 7,
+  SpvMemorySemanticsWorkgroupMemoryShift = 8,
+  SpvMemorySemanticsCrossWorkgroupMemoryShift = 9,
+  SpvMemorySemanticsAtomicCounterMemoryShift = 10,
+  SpvMemorySemanticsImageMemoryShift = 11,
+  SpvMemorySemanticsOutputMemoryShift = 12,
+  SpvMemorySemanticsOutputMemoryKHRShift = 12,
+  SpvMemorySemanticsMakeAvailableShift = 13,
+  SpvMemorySemanticsMakeAvailableKHRShift = 13,
+  SpvMemorySemanticsMakeVisibleShift = 14,
+  SpvMemorySemanticsMakeVisibleKHRShift = 14,
+  SpvMemorySemanticsVolatileShift = 15,
+  SpvMemorySemanticsMax = 0x7fffffff,
 } SpvMemorySemanticsShift;
 
 typedef enum SpvMemorySemanticsMask_ {
-    SpvMemorySemanticsMaskNone = 0,
-    SpvMemorySemanticsAcquireMask = 0x00000002,
-    SpvMemorySemanticsReleaseMask = 0x00000004,
-    SpvMemorySemanticsAcquireReleaseMask = 0x00000008,
-    SpvMemorySemanticsSequentiallyConsistentMask = 0x00000010,
-    SpvMemorySemanticsUniformMemoryMask = 0x00000040,
-    SpvMemorySemanticsSubgroupMemoryMask = 0x00000080,
-    SpvMemorySemanticsWorkgroupMemoryMask = 0x00000100,
-    SpvMemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
-    SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000400,
-    SpvMemorySemanticsImageMemoryMask = 0x00000800,
-    SpvMemorySemanticsOutputMemoryMask = 0x00001000,
-    SpvMemorySemanticsOutputMemoryKHRMask = 0x00001000,
-    SpvMemorySemanticsMakeAvailableMask = 0x00002000,
-    SpvMemorySemanticsMakeAvailableKHRMask = 0x00002000,
-    SpvMemorySemanticsMakeVisibleMask = 0x00004000,
-    SpvMemorySemanticsMakeVisibleKHRMask = 0x00004000,
-    SpvMemorySemanticsVolatileMask = 0x00008000,
+  SpvMemorySemanticsMaskNone = 0,
+  SpvMemorySemanticsAcquireMask = 0x00000002,
+  SpvMemorySemanticsReleaseMask = 0x00000004,
+  SpvMemorySemanticsAcquireReleaseMask = 0x00000008,
+  SpvMemorySemanticsSequentiallyConsistentMask = 0x00000010,
+  SpvMemorySemanticsUniformMemoryMask = 0x00000040,
+  SpvMemorySemanticsSubgroupMemoryMask = 0x00000080,
+  SpvMemorySemanticsWorkgroupMemoryMask = 0x00000100,
+  SpvMemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
+  SpvMemorySemanticsAtomicCounterMemoryMask = 0x00000400,
+  SpvMemorySemanticsImageMemoryMask = 0x00000800,
+  SpvMemorySemanticsOutputMemoryMask = 0x00001000,
+  SpvMemorySemanticsOutputMemoryKHRMask = 0x00001000,
+  SpvMemorySemanticsMakeAvailableMask = 0x00002000,
+  SpvMemorySemanticsMakeAvailableKHRMask = 0x00002000,
+  SpvMemorySemanticsMakeVisibleMask = 0x00004000,
+  SpvMemorySemanticsMakeVisibleKHRMask = 0x00004000,
+  SpvMemorySemanticsVolatileMask = 0x00008000,
 } SpvMemorySemanticsMask;
 
 typedef enum SpvMemoryAccessShift_ {
-    SpvMemoryAccessVolatileShift = 0,
-    SpvMemoryAccessAlignedShift = 1,
-    SpvMemoryAccessNontemporalShift = 2,
-    SpvMemoryAccessMakePointerAvailableShift = 3,
-    SpvMemoryAccessMakePointerAvailableKHRShift = 3,
-    SpvMemoryAccessMakePointerVisibleShift = 4,
-    SpvMemoryAccessMakePointerVisibleKHRShift = 4,
-    SpvMemoryAccessNonPrivatePointerShift = 5,
-    SpvMemoryAccessNonPrivatePointerKHRShift = 5,
-    SpvMemoryAccessMax = 0x7fffffff,
+  SpvMemoryAccessVolatileShift = 0,
+  SpvMemoryAccessAlignedShift = 1,
+  SpvMemoryAccessNontemporalShift = 2,
+  SpvMemoryAccessMakePointerAvailableShift = 3,
+  SpvMemoryAccessMakePointerAvailableKHRShift = 3,
+  SpvMemoryAccessMakePointerVisibleShift = 4,
+  SpvMemoryAccessMakePointerVisibleKHRShift = 4,
+  SpvMemoryAccessNonPrivatePointerShift = 5,
+  SpvMemoryAccessNonPrivatePointerKHRShift = 5,
+  SpvMemoryAccessAliasScopeINTELMaskShift = 16,
+  SpvMemoryAccessNoAliasINTELMaskShift = 17,
+  SpvMemoryAccessMax = 0x7fffffff,
 } SpvMemoryAccessShift;
 
 typedef enum SpvMemoryAccessMask_ {
-    SpvMemoryAccessMaskNone = 0,
-    SpvMemoryAccessVolatileMask = 0x00000001,
-    SpvMemoryAccessAlignedMask = 0x00000002,
-    SpvMemoryAccessNontemporalMask = 0x00000004,
-    SpvMemoryAccessMakePointerAvailableMask = 0x00000008,
-    SpvMemoryAccessMakePointerAvailableKHRMask = 0x00000008,
-    SpvMemoryAccessMakePointerVisibleMask = 0x00000010,
-    SpvMemoryAccessMakePointerVisibleKHRMask = 0x00000010,
-    SpvMemoryAccessNonPrivatePointerMask = 0x00000020,
-    SpvMemoryAccessNonPrivatePointerKHRMask = 0x00000020,
+  SpvMemoryAccessMaskNone = 0,
+  SpvMemoryAccessVolatileMask = 0x00000001,
+  SpvMemoryAccessAlignedMask = 0x00000002,
+  SpvMemoryAccessNontemporalMask = 0x00000004,
+  SpvMemoryAccessMakePointerAvailableMask = 0x00000008,
+  SpvMemoryAccessMakePointerAvailableKHRMask = 0x00000008,
+  SpvMemoryAccessMakePointerVisibleMask = 0x00000010,
+  SpvMemoryAccessMakePointerVisibleKHRMask = 0x00000010,
+  SpvMemoryAccessNonPrivatePointerMask = 0x00000020,
+  SpvMemoryAccessNonPrivatePointerKHRMask = 0x00000020,
+  SpvMemoryAccessAliasScopeINTELMaskMask = 0x00010000,
+  SpvMemoryAccessNoAliasINTELMaskMask = 0x00020000,
 } SpvMemoryAccessMask;
 
 typedef enum SpvScope_ {
-    SpvScopeCrossDevice = 0,
-    SpvScopeDevice = 1,
-    SpvScopeWorkgroup = 2,
-    SpvScopeSubgroup = 3,
-    SpvScopeInvocation = 4,
-    SpvScopeQueueFamily = 5,
-    SpvScopeQueueFamilyKHR = 5,
-    SpvScopeShaderCallKHR = 6,
-    SpvScopeMax = 0x7fffffff,
+  SpvScopeCrossDevice = 0,
+  SpvScopeDevice = 1,
+  SpvScopeWorkgroup = 2,
+  SpvScopeSubgroup = 3,
+  SpvScopeInvocation = 4,
+  SpvScopeQueueFamily = 5,
+  SpvScopeQueueFamilyKHR = 5,
+  SpvScopeShaderCallKHR = 6,
+  SpvScopeMax = 0x7fffffff,
 } SpvScope;
 
 typedef enum SpvGroupOperation_ {
-    SpvGroupOperationReduce = 0,
-    SpvGroupOperationInclusiveScan = 1,
-    SpvGroupOperationExclusiveScan = 2,
-    SpvGroupOperationClusteredReduce = 3,
-    SpvGroupOperationPartitionedReduceNV = 6,
-    SpvGroupOperationPartitionedInclusiveScanNV = 7,
-    SpvGroupOperationPartitionedExclusiveScanNV = 8,
-    SpvGroupOperationMax = 0x7fffffff,
+  SpvGroupOperationReduce = 0,
+  SpvGroupOperationInclusiveScan = 1,
+  SpvGroupOperationExclusiveScan = 2,
+  SpvGroupOperationClusteredReduce = 3,
+  SpvGroupOperationPartitionedReduceNV = 6,
+  SpvGroupOperationPartitionedInclusiveScanNV = 7,
+  SpvGroupOperationPartitionedExclusiveScanNV = 8,
+  SpvGroupOperationMax = 0x7fffffff,
 } SpvGroupOperation;
 
 typedef enum SpvKernelEnqueueFlags_ {
-    SpvKernelEnqueueFlagsNoWait = 0,
-    SpvKernelEnqueueFlagsWaitKernel = 1,
-    SpvKernelEnqueueFlagsWaitWorkGroup = 2,
-    SpvKernelEnqueueFlagsMax = 0x7fffffff,
+  SpvKernelEnqueueFlagsNoWait = 0,
+  SpvKernelEnqueueFlagsWaitKernel = 1,
+  SpvKernelEnqueueFlagsWaitWorkGroup = 2,
+  SpvKernelEnqueueFlagsMax = 0x7fffffff,
 } SpvKernelEnqueueFlags;
 
 typedef enum SpvKernelProfilingInfoShift_ {
-    SpvKernelProfilingInfoCmdExecTimeShift = 0,
-    SpvKernelProfilingInfoMax = 0x7fffffff,
+  SpvKernelProfilingInfoCmdExecTimeShift = 0,
+  SpvKernelProfilingInfoMax = 0x7fffffff,
 } SpvKernelProfilingInfoShift;
 
 typedef enum SpvKernelProfilingInfoMask_ {
-    SpvKernelProfilingInfoMaskNone = 0,
-    SpvKernelProfilingInfoCmdExecTimeMask = 0x00000001,
+  SpvKernelProfilingInfoMaskNone = 0,
+  SpvKernelProfilingInfoCmdExecTimeMask = 0x00000001,
 } SpvKernelProfilingInfoMask;
 
 typedef enum SpvCapability_ {
-    SpvCapabilityMatrix = 0,
-    SpvCapabilityShader = 1,
-    SpvCapabilityGeometry = 2,
-    SpvCapabilityTessellation = 3,
-    SpvCapabilityAddresses = 4,
-    SpvCapabilityLinkage = 5,
-    SpvCapabilityKernel = 6,
-    SpvCapabilityVector16 = 7,
-    SpvCapabilityFloat16Buffer = 8,
-    SpvCapabilityFloat16 = 9,
-    SpvCapabilityFloat64 = 10,
-    SpvCapabilityInt64 = 11,
-    SpvCapabilityInt64Atomics = 12,
-    SpvCapabilityImageBasic = 13,
-    SpvCapabilityImageReadWrite = 14,
-    SpvCapabilityImageMipmap = 15,
-    SpvCapabilityPipes = 17,
-    SpvCapabilityGroups = 18,
-    SpvCapabilityDeviceEnqueue = 19,
-    SpvCapabilityLiteralSampler = 20,
-    SpvCapabilityAtomicStorage = 21,
-    SpvCapabilityInt16 = 22,
-    SpvCapabilityTessellationPointSize = 23,
-    SpvCapabilityGeometryPointSize = 24,
-    SpvCapabilityImageGatherExtended = 25,
-    SpvCapabilityStorageImageMultisample = 27,
-    SpvCapabilityUniformBufferArrayDynamicIndexing = 28,
-    SpvCapabilitySampledImageArrayDynamicIndexing = 29,
-    SpvCapabilityStorageBufferArrayDynamicIndexing = 30,
-    SpvCapabilityStorageImageArrayDynamicIndexing = 31,
-    SpvCapabilityClipDistance = 32,
-    SpvCapabilityCullDistance = 33,
-    SpvCapabilityImageCubeArray = 34,
-    SpvCapabilitySampleRateShading = 35,
-    SpvCapabilityImageRect = 36,
-    SpvCapabilitySampledRect = 37,
-    SpvCapabilityGenericPointer = 38,
-    SpvCapabilityInt8 = 39,
-    SpvCapabilityInputAttachment = 40,
-    SpvCapabilitySparseResidency = 41,
-    SpvCapabilityMinLod = 42,
-    SpvCapabilitySampled1D = 43,
-    SpvCapabilityImage1D = 44,
-    SpvCapabilitySampledCubeArray = 45,
-    SpvCapabilitySampledBuffer = 46,
-    SpvCapabilityImageBuffer = 47,
-    SpvCapabilityImageMSArray = 48,
-    SpvCapabilityStorageImageExtendedFormats = 49,
-    SpvCapabilityImageQuery = 50,
-    SpvCapabilityDerivativeControl = 51,
-    SpvCapabilityInterpolationFunction = 52,
-    SpvCapabilityTransformFeedback = 53,
-    SpvCapabilityGeometryStreams = 54,
-    SpvCapabilityStorageImageReadWithoutFormat = 55,
-    SpvCapabilityStorageImageWriteWithoutFormat = 56,
-    SpvCapabilityMultiViewport = 57,
-    SpvCapabilitySubgroupDispatch = 58,
-    SpvCapabilityNamedBarrier = 59,
-    SpvCapabilityPipeStorage = 60,
-    SpvCapabilityGroupNonUniform = 61,
-    SpvCapabilityGroupNonUniformVote = 62,
-    SpvCapabilityGroupNonUniformArithmetic = 63,
-    SpvCapabilityGroupNonUniformBallot = 64,
-    SpvCapabilityGroupNonUniformShuffle = 65,
-    SpvCapabilityGroupNonUniformShuffleRelative = 66,
-    SpvCapabilityGroupNonUniformClustered = 67,
-    SpvCapabilityGroupNonUniformQuad = 68,
-    SpvCapabilityShaderLayer = 69,
-    SpvCapabilityShaderViewportIndex = 70,
-    SpvCapabilityFragmentShadingRateKHR = 4422,
-    SpvCapabilitySubgroupBallotKHR = 4423,
-    SpvCapabilityDrawParameters = 4427,
-    SpvCapabilitySubgroupVoteKHR = 4431,
-    SpvCapabilityStorageBuffer16BitAccess = 4433,
-    SpvCapabilityStorageUniformBufferBlock16 = 4433,
-    SpvCapabilityStorageUniform16 = 4434,
-    SpvCapabilityUniformAndStorageBuffer16BitAccess = 4434,
-    SpvCapabilityStoragePushConstant16 = 4435,
-    SpvCapabilityStorageInputOutput16 = 4436,
-    SpvCapabilityDeviceGroup = 4437,
-    SpvCapabilityMultiView = 4439,
-    SpvCapabilityVariablePointersStorageBuffer = 4441,
-    SpvCapabilityVariablePointers = 4442,
-    SpvCapabilityAtomicStorageOps = 4445,
-    SpvCapabilitySampleMaskPostDepthCoverage = 4447,
-    SpvCapabilityStorageBuffer8BitAccess = 4448,
-    SpvCapabilityUniformAndStorageBuffer8BitAccess = 4449,
-    SpvCapabilityStoragePushConstant8 = 4450,
-    SpvCapabilityDenormPreserve = 4464,
-    SpvCapabilityDenormFlushToZero = 4465,
-    SpvCapabilitySignedZeroInfNanPreserve = 4466,
-    SpvCapabilityRoundingModeRTE = 4467,
-    SpvCapabilityRoundingModeRTZ = 4468,
-    SpvCapabilityRayQueryProvisionalKHR = 4471,
-    SpvCapabilityRayQueryKHR = 4472,
-    SpvCapabilityRayTraversalPrimitiveCullingKHR = 4478,
-    SpvCapabilityRayTracingKHR = 4479,
-    SpvCapabilityFloat16ImageAMD = 5008,
-    SpvCapabilityImageGatherBiasLodAMD = 5009,
-    SpvCapabilityFragmentMaskAMD = 5010,
-    SpvCapabilityStencilExportEXT = 5013,
-    SpvCapabilityImageReadWriteLodAMD = 5015,
-    SpvCapabilityInt64ImageEXT = 5016,
-    SpvCapabilityShaderClockKHR = 5055,
-    SpvCapabilitySampleMaskOverrideCoverageNV = 5249,
-    SpvCapabilityGeometryShaderPassthroughNV = 5251,
-    SpvCapabilityShaderViewportIndexLayerEXT = 5254,
-    SpvCapabilityShaderViewportIndexLayerNV = 5254,
-    SpvCapabilityShaderViewportMaskNV = 5255,
-    SpvCapabilityShaderStereoViewNV = 5259,
-    SpvCapabilityPerViewAttributesNV = 5260,
-    SpvCapabilityFragmentFullyCoveredEXT = 5265,
-    SpvCapabilityMeshShadingNV = 5266,
-    SpvCapabilityImageFootprintNV = 5282,
-    SpvCapabilityFragmentBarycentricNV = 5284,
-    SpvCapabilityComputeDerivativeGroupQuadsNV = 5288,
-    SpvCapabilityFragmentDensityEXT = 5291,
-    SpvCapabilityShadingRateNV = 5291,
-    SpvCapabilityGroupNonUniformPartitionedNV = 5297,
-    SpvCapabilityShaderNonUniform = 5301,
-    SpvCapabilityShaderNonUniformEXT = 5301,
-    SpvCapabilityRuntimeDescriptorArray = 5302,
-    SpvCapabilityRuntimeDescriptorArrayEXT = 5302,
-    SpvCapabilityInputAttachmentArrayDynamicIndexing = 5303,
-    SpvCapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
-    SpvCapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
-    SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
-    SpvCapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
-    SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
-    SpvCapabilityUniformBufferArrayNonUniformIndexing = 5306,
-    SpvCapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
-    SpvCapabilitySampledImageArrayNonUniformIndexing = 5307,
-    SpvCapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
-    SpvCapabilityStorageBufferArrayNonUniformIndexing = 5308,
-    SpvCapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
-    SpvCapabilityStorageImageArrayNonUniformIndexing = 5309,
-    SpvCapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
-    SpvCapabilityInputAttachmentArrayNonUniformIndexing = 5310,
-    SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
-    SpvCapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
-    SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
-    SpvCapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
-    SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
-    SpvCapabilityRayTracingNV = 5340,
-    SpvCapabilityVulkanMemoryModel = 5345,
-    SpvCapabilityVulkanMemoryModelKHR = 5345,
-    SpvCapabilityVulkanMemoryModelDeviceScope = 5346,
-    SpvCapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
-    SpvCapabilityPhysicalStorageBufferAddresses = 5347,
-    SpvCapabilityPhysicalStorageBufferAddressesEXT = 5347,
-    SpvCapabilityComputeDerivativeGroupLinearNV = 5350,
-    SpvCapabilityRayTracingProvisionalKHR = 5353,
-    SpvCapabilityCooperativeMatrixNV = 5357,
-    SpvCapabilityFragmentShaderSampleInterlockEXT = 5363,
-    SpvCapabilityFragmentShaderShadingRateInterlockEXT = 5372,
-    SpvCapabilityShaderSMBuiltinsNV = 5373,
-    SpvCapabilityFragmentShaderPixelInterlockEXT = 5378,
-    SpvCapabilityDemoteToHelperInvocationEXT = 5379,
-    SpvCapabilitySubgroupShuffleINTEL = 5568,
-    SpvCapabilitySubgroupBufferBlockIOINTEL = 5569,
-    SpvCapabilitySubgroupImageBlockIOINTEL = 5570,
-    SpvCapabilitySubgroupImageMediaBlockIOINTEL = 5579,
-    SpvCapabilityIntegerFunctions2INTEL = 5584,
-    SpvCapabilityFunctionPointersINTEL = 5603,
-    SpvCapabilityIndirectReferencesINTEL = 5604,
-    SpvCapabilitySubgroupAvcMotionEstimationINTEL = 5696,
-    SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
-    SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
-    SpvCapabilityFPGAMemoryAttributesINTEL = 5824,
-    SpvCapabilityUnstructuredLoopControlsINTEL = 5886,
-    SpvCapabilityFPGALoopControlsINTEL = 5888,
-    SpvCapabilityKernelAttributesINTEL = 5892,
-    SpvCapabilityFPGAKernelAttributesINTEL = 5897,
-    SpvCapabilityBlockingPipesINTEL = 5945,
-    SpvCapabilityFPGARegINTEL = 5948,
-    SpvCapabilityAtomicFloat32AddEXT = 6033,
-    SpvCapabilityAtomicFloat64AddEXT = 6034,
-    SpvCapabilityMax = 0x7fffffff,
+  SpvCapabilityMatrix = 0,
+  SpvCapabilityShader = 1,
+  SpvCapabilityGeometry = 2,
+  SpvCapabilityTessellation = 3,
+  SpvCapabilityAddresses = 4,
+  SpvCapabilityLinkage = 5,
+  SpvCapabilityKernel = 6,
+  SpvCapabilityVector16 = 7,
+  SpvCapabilityFloat16Buffer = 8,
+  SpvCapabilityFloat16 = 9,
+  SpvCapabilityFloat64 = 10,
+  SpvCapabilityInt64 = 11,
+  SpvCapabilityInt64Atomics = 12,
+  SpvCapabilityImageBasic = 13,
+  SpvCapabilityImageReadWrite = 14,
+  SpvCapabilityImageMipmap = 15,
+  SpvCapabilityPipes = 17,
+  SpvCapabilityGroups = 18,
+  SpvCapabilityDeviceEnqueue = 19,
+  SpvCapabilityLiteralSampler = 20,
+  SpvCapabilityAtomicStorage = 21,
+  SpvCapabilityInt16 = 22,
+  SpvCapabilityTessellationPointSize = 23,
+  SpvCapabilityGeometryPointSize = 24,
+  SpvCapabilityImageGatherExtended = 25,
+  SpvCapabilityStorageImageMultisample = 27,
+  SpvCapabilityUniformBufferArrayDynamicIndexing = 28,
+  SpvCapabilitySampledImageArrayDynamicIndexing = 29,
+  SpvCapabilityStorageBufferArrayDynamicIndexing = 30,
+  SpvCapabilityStorageImageArrayDynamicIndexing = 31,
+  SpvCapabilityClipDistance = 32,
+  SpvCapabilityCullDistance = 33,
+  SpvCapabilityImageCubeArray = 34,
+  SpvCapabilitySampleRateShading = 35,
+  SpvCapabilityImageRect = 36,
+  SpvCapabilitySampledRect = 37,
+  SpvCapabilityGenericPointer = 38,
+  SpvCapabilityInt8 = 39,
+  SpvCapabilityInputAttachment = 40,
+  SpvCapabilitySparseResidency = 41,
+  SpvCapabilityMinLod = 42,
+  SpvCapabilitySampled1D = 43,
+  SpvCapabilityImage1D = 44,
+  SpvCapabilitySampledCubeArray = 45,
+  SpvCapabilitySampledBuffer = 46,
+  SpvCapabilityImageBuffer = 47,
+  SpvCapabilityImageMSArray = 48,
+  SpvCapabilityStorageImageExtendedFormats = 49,
+  SpvCapabilityImageQuery = 50,
+  SpvCapabilityDerivativeControl = 51,
+  SpvCapabilityInterpolationFunction = 52,
+  SpvCapabilityTransformFeedback = 53,
+  SpvCapabilityGeometryStreams = 54,
+  SpvCapabilityStorageImageReadWithoutFormat = 55,
+  SpvCapabilityStorageImageWriteWithoutFormat = 56,
+  SpvCapabilityMultiViewport = 57,
+  SpvCapabilitySubgroupDispatch = 58,
+  SpvCapabilityNamedBarrier = 59,
+  SpvCapabilityPipeStorage = 60,
+  SpvCapabilityGroupNonUniform = 61,
+  SpvCapabilityGroupNonUniformVote = 62,
+  SpvCapabilityGroupNonUniformArithmetic = 63,
+  SpvCapabilityGroupNonUniformBallot = 64,
+  SpvCapabilityGroupNonUniformShuffle = 65,
+  SpvCapabilityGroupNonUniformShuffleRelative = 66,
+  SpvCapabilityGroupNonUniformClustered = 67,
+  SpvCapabilityGroupNonUniformQuad = 68,
+  SpvCapabilityShaderLayer = 69,
+  SpvCapabilityShaderViewportIndex = 70,
+  SpvCapabilityUniformDecoration = 71,
+  SpvCapabilityCoreBuiltinsARM = 4165,
+  SpvCapabilityTileImageColorReadAccessEXT = 4166,
+  SpvCapabilityTileImageDepthReadAccessEXT = 4167,
+  SpvCapabilityTileImageStencilReadAccessEXT = 4168,
+  SpvCapabilityFragmentShadingRateKHR = 4422,
+  SpvCapabilitySubgroupBallotKHR = 4423,
+  SpvCapabilityDrawParameters = 4427,
+  SpvCapabilityWorkgroupMemoryExplicitLayoutKHR = 4428,
+  SpvCapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
+  SpvCapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
+  SpvCapabilitySubgroupVoteKHR = 4431,
+  SpvCapabilityStorageBuffer16BitAccess = 4433,
+  SpvCapabilityStorageUniformBufferBlock16 = 4433,
+  SpvCapabilityStorageUniform16 = 4434,
+  SpvCapabilityUniformAndStorageBuffer16BitAccess = 4434,
+  SpvCapabilityStoragePushConstant16 = 4435,
+  SpvCapabilityStorageInputOutput16 = 4436,
+  SpvCapabilityDeviceGroup = 4437,
+  SpvCapabilityMultiView = 4439,
+  SpvCapabilityVariablePointersStorageBuffer = 4441,
+  SpvCapabilityVariablePointers = 4442,
+  SpvCapabilityAtomicStorageOps = 4445,
+  SpvCapabilitySampleMaskPostDepthCoverage = 4447,
+  SpvCapabilityStorageBuffer8BitAccess = 4448,
+  SpvCapabilityUniformAndStorageBuffer8BitAccess = 4449,
+  SpvCapabilityStoragePushConstant8 = 4450,
+  SpvCapabilityDenormPreserve = 4464,
+  SpvCapabilityDenormFlushToZero = 4465,
+  SpvCapabilitySignedZeroInfNanPreserve = 4466,
+  SpvCapabilityRoundingModeRTE = 4467,
+  SpvCapabilityRoundingModeRTZ = 4468,
+  SpvCapabilityRayQueryProvisionalKHR = 4471,
+  SpvCapabilityRayQueryKHR = 4472,
+  SpvCapabilityRayTraversalPrimitiveCullingKHR = 4478,
+  SpvCapabilityRayTracingKHR = 4479,
+  SpvCapabilityTextureSampleWeightedQCOM = 4484,
+  SpvCapabilityTextureBoxFilterQCOM = 4485,
+  SpvCapabilityTextureBlockMatchQCOM = 4486,
+  SpvCapabilityFloat16ImageAMD = 5008,
+  SpvCapabilityImageGatherBiasLodAMD = 5009,
+  SpvCapabilityFragmentMaskAMD = 5010,
+  SpvCapabilityStencilExportEXT = 5013,
+  SpvCapabilityImageReadWriteLodAMD = 5015,
+  SpvCapabilityInt64ImageEXT = 5016,
+  SpvCapabilityShaderClockKHR = 5055,
+  SpvCapabilitySampleMaskOverrideCoverageNV = 5249,
+  SpvCapabilityGeometryShaderPassthroughNV = 5251,
+  SpvCapabilityShaderViewportIndexLayerEXT = 5254,
+  SpvCapabilityShaderViewportIndexLayerNV = 5254,
+  SpvCapabilityShaderViewportMaskNV = 5255,
+  SpvCapabilityShaderStereoViewNV = 5259,
+  SpvCapabilityPerViewAttributesNV = 5260,
+  SpvCapabilityFragmentFullyCoveredEXT = 5265,
+  SpvCapabilityMeshShadingNV = 5266,
+  SpvCapabilityImageFootprintNV = 5282,
+  SpvCapabilityMeshShadingEXT = 5283,
+  SpvCapabilityFragmentBarycentricKHR = 5284,
+  SpvCapabilityFragmentBarycentricNV = 5284,
+  SpvCapabilityComputeDerivativeGroupQuadsNV = 5288,
+  SpvCapabilityFragmentDensityEXT = 5291,
+  SpvCapabilityShadingRateNV = 5291,
+  SpvCapabilityGroupNonUniformPartitionedNV = 5297,
+  SpvCapabilityShaderNonUniform = 5301,
+  SpvCapabilityShaderNonUniformEXT = 5301,
+  SpvCapabilityRuntimeDescriptorArray = 5302,
+  SpvCapabilityRuntimeDescriptorArrayEXT = 5302,
+  SpvCapabilityInputAttachmentArrayDynamicIndexing = 5303,
+  SpvCapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
+  SpvCapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
+  SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
+  SpvCapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
+  SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
+  SpvCapabilityUniformBufferArrayNonUniformIndexing = 5306,
+  SpvCapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
+  SpvCapabilitySampledImageArrayNonUniformIndexing = 5307,
+  SpvCapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
+  SpvCapabilityStorageBufferArrayNonUniformIndexing = 5308,
+  SpvCapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
+  SpvCapabilityStorageImageArrayNonUniformIndexing = 5309,
+  SpvCapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
+  SpvCapabilityInputAttachmentArrayNonUniformIndexing = 5310,
+  SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
+  SpvCapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
+  SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+  SpvCapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
+  SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+  SpvCapabilityRayTracingPositionFetchKHR = 5336,
+  SpvCapabilityRayTracingNV = 5340,
+  SpvCapabilityRayTracingMotionBlurNV = 5341,
+  SpvCapabilityVulkanMemoryModel = 5345,
+  SpvCapabilityVulkanMemoryModelKHR = 5345,
+  SpvCapabilityVulkanMemoryModelDeviceScope = 5346,
+  SpvCapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
+  SpvCapabilityPhysicalStorageBufferAddresses = 5347,
+  SpvCapabilityPhysicalStorageBufferAddressesEXT = 5347,
+  SpvCapabilityComputeDerivativeGroupLinearNV = 5350,
+  SpvCapabilityRayTracingProvisionalKHR = 5353,
+  SpvCapabilityCooperativeMatrixNV = 5357,
+  SpvCapabilityFragmentShaderSampleInterlockEXT = 5363,
+  SpvCapabilityFragmentShaderShadingRateInterlockEXT = 5372,
+  SpvCapabilityShaderSMBuiltinsNV = 5373,
+  SpvCapabilityFragmentShaderPixelInterlockEXT = 5378,
+  SpvCapabilityDemoteToHelperInvocation = 5379,
+  SpvCapabilityDemoteToHelperInvocationEXT = 5379,
+  SpvCapabilityRayTracingOpacityMicromapEXT = 5381,
+  SpvCapabilityShaderInvocationReorderNV = 5383,
+  SpvCapabilityBindlessTextureNV = 5390,
+  SpvCapabilityRayQueryPositionFetchKHR = 5391,
+  SpvCapabilitySubgroupShuffleINTEL = 5568,
+  SpvCapabilitySubgroupBufferBlockIOINTEL = 5569,
+  SpvCapabilitySubgroupImageBlockIOINTEL = 5570,
+  SpvCapabilitySubgroupImageMediaBlockIOINTEL = 5579,
+  SpvCapabilityRoundToInfinityINTEL = 5582,
+  SpvCapabilityFloatingPointModeINTEL = 5583,
+  SpvCapabilityIntegerFunctions2INTEL = 5584,
+  SpvCapabilityFunctionPointersINTEL = 5603,
+  SpvCapabilityIndirectReferencesINTEL = 5604,
+  SpvCapabilityAsmINTEL = 5606,
+  SpvCapabilityAtomicFloat32MinMaxEXT = 5612,
+  SpvCapabilityAtomicFloat64MinMaxEXT = 5613,
+  SpvCapabilityAtomicFloat16MinMaxEXT = 5616,
+  SpvCapabilityVectorComputeINTEL = 5617,
+  SpvCapabilityVectorAnyINTEL = 5619,
+  SpvCapabilityExpectAssumeKHR = 5629,
+  SpvCapabilitySubgroupAvcMotionEstimationINTEL = 5696,
+  SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
+  SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
+  SpvCapabilityVariableLengthArrayINTEL = 5817,
+  SpvCapabilityFunctionFloatControlINTEL = 5821,
+  SpvCapabilityFPGAMemoryAttributesINTEL = 5824,
+  SpvCapabilityFPFastMathModeINTEL = 5837,
+  SpvCapabilityArbitraryPrecisionIntegersINTEL = 5844,
+  SpvCapabilityArbitraryPrecisionFloatingPointINTEL = 5845,
+  SpvCapabilityUnstructuredLoopControlsINTEL = 5886,
+  SpvCapabilityFPGALoopControlsINTEL = 5888,
+  SpvCapabilityKernelAttributesINTEL = 5892,
+  SpvCapabilityFPGAKernelAttributesINTEL = 5897,
+  SpvCapabilityFPGAMemoryAccessesINTEL = 5898,
+  SpvCapabilityFPGAClusterAttributesINTEL = 5904,
+  SpvCapabilityLoopFuseINTEL = 5906,
+  SpvCapabilityFPGADSPControlINTEL = 5908,
+  SpvCapabilityMemoryAccessAliasingINTEL = 5910,
+  SpvCapabilityFPGAInvocationPipeliningAttributesINTEL = 5916,
+  SpvCapabilityFPGABufferLocationINTEL = 5920,
+  SpvCapabilityArbitraryPrecisionFixedPointINTEL = 5922,
+  SpvCapabilityUSMStorageClassesINTEL = 5935,
+  SpvCapabilityRuntimeAlignedAttributeINTEL = 5939,
+  SpvCapabilityIOPipesINTEL = 5943,
+  SpvCapabilityBlockingPipesINTEL = 5945,
+  SpvCapabilityFPGARegINTEL = 5948,
+  SpvCapabilityDotProductInputAll = 6016,
+  SpvCapabilityDotProductInputAllKHR = 6016,
+  SpvCapabilityDotProductInput4x8Bit = 6017,
+  SpvCapabilityDotProductInput4x8BitKHR = 6017,
+  SpvCapabilityDotProductInput4x8BitPacked = 6018,
+  SpvCapabilityDotProductInput4x8BitPackedKHR = 6018,
+  SpvCapabilityDotProduct = 6019,
+  SpvCapabilityDotProductKHR = 6019,
+  SpvCapabilityRayCullMaskKHR = 6020,
+  SpvCapabilityCooperativeMatrixKHR = 6022,
+  SpvCapabilityBitInstructions = 6025,
+  SpvCapabilityGroupNonUniformRotateKHR = 6026,
+  SpvCapabilityAtomicFloat32AddEXT = 6033,
+  SpvCapabilityAtomicFloat64AddEXT = 6034,
+  SpvCapabilityLongConstantCompositeINTEL = 6089,
+  SpvCapabilityOptNoneINTEL = 6094,
+  SpvCapabilityAtomicFloat16AddEXT = 6095,
+  SpvCapabilityDebugInfoModuleINTEL = 6114,
+  SpvCapabilityBFloat16ConversionINTEL = 6115,
+  SpvCapabilitySplitBarrierINTEL = 6141,
+  SpvCapabilityFPGAKernelAttributesv2INTEL = 6161,
+  SpvCapabilityFPGALatencyControlINTEL = 6171,
+  SpvCapabilityFPGAArgumentInterfacesINTEL = 6174,
+  SpvCapabilityGroupUniformArithmeticKHR = 6400,
+  SpvCapabilityMax = 0x7fffffff,
 } SpvCapability;
 
 typedef enum SpvRayFlagsShift_ {
-    SpvRayFlagsOpaqueKHRShift = 0,
-    SpvRayFlagsNoOpaqueKHRShift = 1,
-    SpvRayFlagsTerminateOnFirstHitKHRShift = 2,
-    SpvRayFlagsSkipClosestHitShaderKHRShift = 3,
-    SpvRayFlagsCullBackFacingTrianglesKHRShift = 4,
-    SpvRayFlagsCullFrontFacingTrianglesKHRShift = 5,
-    SpvRayFlagsCullOpaqueKHRShift = 6,
-    SpvRayFlagsCullNoOpaqueKHRShift = 7,
-    SpvRayFlagsSkipTrianglesKHRShift = 8,
-    SpvRayFlagsSkipAABBsKHRShift = 9,
-    SpvRayFlagsMax = 0x7fffffff,
+  SpvRayFlagsOpaqueKHRShift = 0,
+  SpvRayFlagsNoOpaqueKHRShift = 1,
+  SpvRayFlagsTerminateOnFirstHitKHRShift = 2,
+  SpvRayFlagsSkipClosestHitShaderKHRShift = 3,
+  SpvRayFlagsCullBackFacingTrianglesKHRShift = 4,
+  SpvRayFlagsCullFrontFacingTrianglesKHRShift = 5,
+  SpvRayFlagsCullOpaqueKHRShift = 6,
+  SpvRayFlagsCullNoOpaqueKHRShift = 7,
+  SpvRayFlagsSkipTrianglesKHRShift = 8,
+  SpvRayFlagsSkipAABBsKHRShift = 9,
+  SpvRayFlagsForceOpacityMicromap2StateEXTShift = 10,
+  SpvRayFlagsMax = 0x7fffffff,
 } SpvRayFlagsShift;
 
 typedef enum SpvRayFlagsMask_ {
-    SpvRayFlagsMaskNone = 0,
-    SpvRayFlagsOpaqueKHRMask = 0x00000001,
-    SpvRayFlagsNoOpaqueKHRMask = 0x00000002,
-    SpvRayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
-    SpvRayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
-    SpvRayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
-    SpvRayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
-    SpvRayFlagsCullOpaqueKHRMask = 0x00000040,
-    SpvRayFlagsCullNoOpaqueKHRMask = 0x00000080,
-    SpvRayFlagsSkipTrianglesKHRMask = 0x00000100,
-    SpvRayFlagsSkipAABBsKHRMask = 0x00000200,
+  SpvRayFlagsMaskNone = 0,
+  SpvRayFlagsOpaqueKHRMask = 0x00000001,
+  SpvRayFlagsNoOpaqueKHRMask = 0x00000002,
+  SpvRayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
+  SpvRayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
+  SpvRayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
+  SpvRayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
+  SpvRayFlagsCullOpaqueKHRMask = 0x00000040,
+  SpvRayFlagsCullNoOpaqueKHRMask = 0x00000080,
+  SpvRayFlagsSkipTrianglesKHRMask = 0x00000100,
+  SpvRayFlagsSkipAABBsKHRMask = 0x00000200,
+  SpvRayFlagsForceOpacityMicromap2StateEXTMask = 0x00000400,
 } SpvRayFlagsMask;
 
 typedef enum SpvRayQueryIntersection_ {
-    SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
-    SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
-    SpvRayQueryIntersectionMax = 0x7fffffff,
+  SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
+  SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
+  SpvRayQueryIntersectionMax = 0x7fffffff,
 } SpvRayQueryIntersection;
 
 typedef enum SpvRayQueryCommittedIntersectionType_ {
-    SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
-    SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
-    SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
-    SpvRayQueryCommittedIntersectionTypeMax = 0x7fffffff,
+  SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
+  SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR =
+      1,
+  SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR =
+      2,
+  SpvRayQueryCommittedIntersectionTypeMax = 0x7fffffff,
 } SpvRayQueryCommittedIntersectionType;
 
 typedef enum SpvRayQueryCandidateIntersectionType_ {
-    SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
-    SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
-    SpvRayQueryCandidateIntersectionTypeMax = 0x7fffffff,
+  SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR =
+      0,
+  SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
+  SpvRayQueryCandidateIntersectionTypeMax = 0x7fffffff,
 } SpvRayQueryCandidateIntersectionType;
 
 typedef enum SpvFragmentShadingRateShift_ {
-    SpvFragmentShadingRateVertical2PixelsShift = 0,
-    SpvFragmentShadingRateVertical4PixelsShift = 1,
-    SpvFragmentShadingRateHorizontal2PixelsShift = 2,
-    SpvFragmentShadingRateHorizontal4PixelsShift = 3,
-    SpvFragmentShadingRateMax = 0x7fffffff,
+  SpvFragmentShadingRateVertical2PixelsShift = 0,
+  SpvFragmentShadingRateVertical4PixelsShift = 1,
+  SpvFragmentShadingRateHorizontal2PixelsShift = 2,
+  SpvFragmentShadingRateHorizontal4PixelsShift = 3,
+  SpvFragmentShadingRateMax = 0x7fffffff,
 } SpvFragmentShadingRateShift;
 
 typedef enum SpvFragmentShadingRateMask_ {
-    SpvFragmentShadingRateMaskNone = 0,
-    SpvFragmentShadingRateVertical2PixelsMask = 0x00000001,
-    SpvFragmentShadingRateVertical4PixelsMask = 0x00000002,
-    SpvFragmentShadingRateHorizontal2PixelsMask = 0x00000004,
-    SpvFragmentShadingRateHorizontal4PixelsMask = 0x00000008,
+  SpvFragmentShadingRateMaskNone = 0,
+  SpvFragmentShadingRateVertical2PixelsMask = 0x00000001,
+  SpvFragmentShadingRateVertical4PixelsMask = 0x00000002,
+  SpvFragmentShadingRateHorizontal2PixelsMask = 0x00000004,
+  SpvFragmentShadingRateHorizontal4PixelsMask = 0x00000008,
 } SpvFragmentShadingRateMask;
 
+typedef enum SpvFPDenormMode_ {
+  SpvFPDenormModePreserve = 0,
+  SpvFPDenormModeFlushToZero = 1,
+  SpvFPDenormModeMax = 0x7fffffff,
+} SpvFPDenormMode;
+
+typedef enum SpvFPOperationMode_ {
+  SpvFPOperationModeIEEE = 0,
+  SpvFPOperationModeALT = 1,
+  SpvFPOperationModeMax = 0x7fffffff,
+} SpvFPOperationMode;
+
+typedef enum SpvQuantizationModes_ {
+  SpvQuantizationModesTRN = 0,
+  SpvQuantizationModesTRN_ZERO = 1,
+  SpvQuantizationModesRND = 2,
+  SpvQuantizationModesRND_ZERO = 3,
+  SpvQuantizationModesRND_INF = 4,
+  SpvQuantizationModesRND_MIN_INF = 5,
+  SpvQuantizationModesRND_CONV = 6,
+  SpvQuantizationModesRND_CONV_ODD = 7,
+  SpvQuantizationModesMax = 0x7fffffff,
+} SpvQuantizationModes;
+
+typedef enum SpvOverflowModes_ {
+  SpvOverflowModesWRAP = 0,
+  SpvOverflowModesSAT = 1,
+  SpvOverflowModesSAT_ZERO = 2,
+  SpvOverflowModesSAT_SYM = 3,
+  SpvOverflowModesMax = 0x7fffffff,
+} SpvOverflowModes;
+
+typedef enum SpvPackedVectorFormat_ {
+  SpvPackedVectorFormatPackedVectorFormat4x8Bit = 0,
+  SpvPackedVectorFormatPackedVectorFormat4x8BitKHR = 0,
+  SpvPackedVectorFormatMax = 0x7fffffff,
+} SpvPackedVectorFormat;
+
+typedef enum SpvCooperativeMatrixOperandsShift_ {
+  SpvCooperativeMatrixOperandsMatrixASignedComponentsShift = 0,
+  SpvCooperativeMatrixOperandsMatrixBSignedComponentsShift = 1,
+  SpvCooperativeMatrixOperandsMatrixCSignedComponentsShift = 2,
+  SpvCooperativeMatrixOperandsMatrixResultSignedComponentsShift = 3,
+  SpvCooperativeMatrixOperandsSaturatingAccumulationShift = 4,
+  SpvCooperativeMatrixOperandsMax = 0x7fffffff,
+} SpvCooperativeMatrixOperandsShift;
+
+typedef enum SpvCooperativeMatrixOperandsMask_ {
+  SpvCooperativeMatrixOperandsMaskNone = 0,
+  SpvCooperativeMatrixOperandsMatrixASignedComponentsMask = 0x00000001,
+  SpvCooperativeMatrixOperandsMatrixBSignedComponentsMask = 0x00000002,
+  SpvCooperativeMatrixOperandsMatrixCSignedComponentsMask = 0x00000004,
+  SpvCooperativeMatrixOperandsMatrixResultSignedComponentsMask = 0x00000008,
+  SpvCooperativeMatrixOperandsSaturatingAccumulationMask = 0x00000010,
+} SpvCooperativeMatrixOperandsMask;
+
+typedef enum SpvCooperativeMatrixLayout_ {
+  SpvCooperativeMatrixLayoutRowMajorKHR = 0,
+  SpvCooperativeMatrixLayoutColumnMajorKHR = 1,
+  SpvCooperativeMatrixLayoutMax = 0x7fffffff,
+} SpvCooperativeMatrixLayout;
+
+typedef enum SpvCooperativeMatrixUse_ {
+  SpvCooperativeMatrixUseMatrixAKHR = 0,
+  SpvCooperativeMatrixUseMatrixBKHR = 1,
+  SpvCooperativeMatrixUseMatrixAccumulatorKHR = 2,
+  SpvCooperativeMatrixUseMax = 0x7fffffff,
+} SpvCooperativeMatrixUse;
+
 typedef enum SpvOp_ {
-    SpvOpNop = 0,
-    SpvOpUndef = 1,
-    SpvOpSourceContinued = 2,
-    SpvOpSource = 3,
-    SpvOpSourceExtension = 4,
-    SpvOpName = 5,
-    SpvOpMemberName = 6,
-    SpvOpString = 7,
-    SpvOpLine = 8,
-    SpvOpExtension = 10,
-    SpvOpExtInstImport = 11,
-    SpvOpExtInst = 12,
-    SpvOpMemoryModel = 14,
-    SpvOpEntryPoint = 15,
-    SpvOpExecutionMode = 16,
-    SpvOpCapability = 17,
-    SpvOpTypeVoid = 19,
-    SpvOpTypeBool = 20,
-    SpvOpTypeInt = 21,
-    SpvOpTypeFloat = 22,
-    SpvOpTypeVector = 23,
-    SpvOpTypeMatrix = 24,
-    SpvOpTypeImage = 25,
-    SpvOpTypeSampler = 26,
-    SpvOpTypeSampledImage = 27,
-    SpvOpTypeArray = 28,
-    SpvOpTypeRuntimeArray = 29,
-    SpvOpTypeStruct = 30,
-    SpvOpTypeOpaque = 31,
-    SpvOpTypePointer = 32,
-    SpvOpTypeFunction = 33,
-    SpvOpTypeEvent = 34,
-    SpvOpTypeDeviceEvent = 35,
-    SpvOpTypeReserveId = 36,
-    SpvOpTypeQueue = 37,
-    SpvOpTypePipe = 38,
-    SpvOpTypeForwardPointer = 39,
-    SpvOpConstantTrue = 41,
-    SpvOpConstantFalse = 42,
-    SpvOpConstant = 43,
-    SpvOpConstantComposite = 44,
-    SpvOpConstantSampler = 45,
-    SpvOpConstantNull = 46,
-    SpvOpSpecConstantTrue = 48,
-    SpvOpSpecConstantFalse = 49,
-    SpvOpSpecConstant = 50,
-    SpvOpSpecConstantComposite = 51,
-    SpvOpSpecConstantOp = 52,
-    SpvOpFunction = 54,
-    SpvOpFunctionParameter = 55,
-    SpvOpFunctionEnd = 56,
-    SpvOpFunctionCall = 57,
-    SpvOpVariable = 59,
-    SpvOpImageTexelPointer = 60,
-    SpvOpLoad = 61,
-    SpvOpStore = 62,
-    SpvOpCopyMemory = 63,
-    SpvOpCopyMemorySized = 64,
-    SpvOpAccessChain = 65,
-    SpvOpInBoundsAccessChain = 66,
-    SpvOpPtrAccessChain = 67,
-    SpvOpArrayLength = 68,
-    SpvOpGenericPtrMemSemantics = 69,
-    SpvOpInBoundsPtrAccessChain = 70,
-    SpvOpDecorate = 71,
-    SpvOpMemberDecorate = 72,
-    SpvOpDecorationGroup = 73,
-    SpvOpGroupDecorate = 74,
-    SpvOpGroupMemberDecorate = 75,
-    SpvOpVectorExtractDynamic = 77,
-    SpvOpVectorInsertDynamic = 78,
-    SpvOpVectorShuffle = 79,
-    SpvOpCompositeConstruct = 80,
-    SpvOpCompositeExtract = 81,
-    SpvOpCompositeInsert = 82,
-    SpvOpCopyObject = 83,
-    SpvOpTranspose = 84,
-    SpvOpSampledImage = 86,
-    SpvOpImageSampleImplicitLod = 87,
-    SpvOpImageSampleExplicitLod = 88,
-    SpvOpImageSampleDrefImplicitLod = 89,
-    SpvOpImageSampleDrefExplicitLod = 90,
-    SpvOpImageSampleProjImplicitLod = 91,
-    SpvOpImageSampleProjExplicitLod = 92,
-    SpvOpImageSampleProjDrefImplicitLod = 93,
-    SpvOpImageSampleProjDrefExplicitLod = 94,
-    SpvOpImageFetch = 95,
-    SpvOpImageGather = 96,
-    SpvOpImageDrefGather = 97,
-    SpvOpImageRead = 98,
-    SpvOpImageWrite = 99,
-    SpvOpImage = 100,
-    SpvOpImageQueryFormat = 101,
-    SpvOpImageQueryOrder = 102,
-    SpvOpImageQuerySizeLod = 103,
-    SpvOpImageQuerySize = 104,
-    SpvOpImageQueryLod = 105,
-    SpvOpImageQueryLevels = 106,
-    SpvOpImageQuerySamples = 107,
-    SpvOpConvertFToU = 109,
-    SpvOpConvertFToS = 110,
-    SpvOpConvertSToF = 111,
-    SpvOpConvertUToF = 112,
-    SpvOpUConvert = 113,
-    SpvOpSConvert = 114,
-    SpvOpFConvert = 115,
-    SpvOpQuantizeToF16 = 116,
-    SpvOpConvertPtrToU = 117,
-    SpvOpSatConvertSToU = 118,
-    SpvOpSatConvertUToS = 119,
-    SpvOpConvertUToPtr = 120,
-    SpvOpPtrCastToGeneric = 121,
-    SpvOpGenericCastToPtr = 122,
-    SpvOpGenericCastToPtrExplicit = 123,
-    SpvOpBitcast = 124,
-    SpvOpSNegate = 126,
-    SpvOpFNegate = 127,
-    SpvOpIAdd = 128,
-    SpvOpFAdd = 129,
-    SpvOpISub = 130,
-    SpvOpFSub = 131,
-    SpvOpIMul = 132,
-    SpvOpFMul = 133,
-    SpvOpUDiv = 134,
-    SpvOpSDiv = 135,
-    SpvOpFDiv = 136,
-    SpvOpUMod = 137,
-    SpvOpSRem = 138,
-    SpvOpSMod = 139,
-    SpvOpFRem = 140,
-    SpvOpFMod = 141,
-    SpvOpVectorTimesScalar = 142,
-    SpvOpMatrixTimesScalar = 143,
-    SpvOpVectorTimesMatrix = 144,
-    SpvOpMatrixTimesVector = 145,
-    SpvOpMatrixTimesMatrix = 146,
-    SpvOpOuterProduct = 147,
-    SpvOpDot = 148,
-    SpvOpIAddCarry = 149,
-    SpvOpISubBorrow = 150,
-    SpvOpUMulExtended = 151,
-    SpvOpSMulExtended = 152,
-    SpvOpAny = 154,
-    SpvOpAll = 155,
-    SpvOpIsNan = 156,
-    SpvOpIsInf = 157,
-    SpvOpIsFinite = 158,
-    SpvOpIsNormal = 159,
-    SpvOpSignBitSet = 160,
-    SpvOpLessOrGreater = 161,
-    SpvOpOrdered = 162,
-    SpvOpUnordered = 163,
-    SpvOpLogicalEqual = 164,
-    SpvOpLogicalNotEqual = 165,
-    SpvOpLogicalOr = 166,
-    SpvOpLogicalAnd = 167,
-    SpvOpLogicalNot = 168,
-    SpvOpSelect = 169,
-    SpvOpIEqual = 170,
-    SpvOpINotEqual = 171,
-    SpvOpUGreaterThan = 172,
-    SpvOpSGreaterThan = 173,
-    SpvOpUGreaterThanEqual = 174,
-    SpvOpSGreaterThanEqual = 175,
-    SpvOpULessThan = 176,
-    SpvOpSLessThan = 177,
-    SpvOpULessThanEqual = 178,
-    SpvOpSLessThanEqual = 179,
-    SpvOpFOrdEqual = 180,
-    SpvOpFUnordEqual = 181,
-    SpvOpFOrdNotEqual = 182,
-    SpvOpFUnordNotEqual = 183,
-    SpvOpFOrdLessThan = 184,
-    SpvOpFUnordLessThan = 185,
-    SpvOpFOrdGreaterThan = 186,
-    SpvOpFUnordGreaterThan = 187,
-    SpvOpFOrdLessThanEqual = 188,
-    SpvOpFUnordLessThanEqual = 189,
-    SpvOpFOrdGreaterThanEqual = 190,
-    SpvOpFUnordGreaterThanEqual = 191,
-    SpvOpShiftRightLogical = 194,
-    SpvOpShiftRightArithmetic = 195,
-    SpvOpShiftLeftLogical = 196,
-    SpvOpBitwiseOr = 197,
-    SpvOpBitwiseXor = 198,
-    SpvOpBitwiseAnd = 199,
-    SpvOpNot = 200,
-    SpvOpBitFieldInsert = 201,
-    SpvOpBitFieldSExtract = 202,
-    SpvOpBitFieldUExtract = 203,
-    SpvOpBitReverse = 204,
-    SpvOpBitCount = 205,
-    SpvOpDPdx = 207,
-    SpvOpDPdy = 208,
-    SpvOpFwidth = 209,
-    SpvOpDPdxFine = 210,
-    SpvOpDPdyFine = 211,
-    SpvOpFwidthFine = 212,
-    SpvOpDPdxCoarse = 213,
-    SpvOpDPdyCoarse = 214,
-    SpvOpFwidthCoarse = 215,
-    SpvOpEmitVertex = 218,
-    SpvOpEndPrimitive = 219,
-    SpvOpEmitStreamVertex = 220,
-    SpvOpEndStreamPrimitive = 221,
-    SpvOpControlBarrier = 224,
-    SpvOpMemoryBarrier = 225,
-    SpvOpAtomicLoad = 227,
-    SpvOpAtomicStore = 228,
-    SpvOpAtomicExchange = 229,
-    SpvOpAtomicCompareExchange = 230,
-    SpvOpAtomicCompareExchangeWeak = 231,
-    SpvOpAtomicIIncrement = 232,
-    SpvOpAtomicIDecrement = 233,
-    SpvOpAtomicIAdd = 234,
-    SpvOpAtomicISub = 235,
-    SpvOpAtomicSMin = 236,
-    SpvOpAtomicUMin = 237,
-    SpvOpAtomicSMax = 238,
-    SpvOpAtomicUMax = 239,
-    SpvOpAtomicAnd = 240,
-    SpvOpAtomicOr = 241,
-    SpvOpAtomicXor = 242,
-    SpvOpPhi = 245,
-    SpvOpLoopMerge = 246,
-    SpvOpSelectionMerge = 247,
-    SpvOpLabel = 248,
-    SpvOpBranch = 249,
-    SpvOpBranchConditional = 250,
-    SpvOpSwitch = 251,
-    SpvOpKill = 252,
-    SpvOpReturn = 253,
-    SpvOpReturnValue = 254,
-    SpvOpUnreachable = 255,
-    SpvOpLifetimeStart = 256,
-    SpvOpLifetimeStop = 257,
-    SpvOpGroupAsyncCopy = 259,
-    SpvOpGroupWaitEvents = 260,
-    SpvOpGroupAll = 261,
-    SpvOpGroupAny = 262,
-    SpvOpGroupBroadcast = 263,
-    SpvOpGroupIAdd = 264,
-    SpvOpGroupFAdd = 265,
-    SpvOpGroupFMin = 266,
-    SpvOpGroupUMin = 267,
-    SpvOpGroupSMin = 268,
-    SpvOpGroupFMax = 269,
-    SpvOpGroupUMax = 270,
-    SpvOpGroupSMax = 271,
-    SpvOpReadPipe = 274,
-    SpvOpWritePipe = 275,
-    SpvOpReservedReadPipe = 276,
-    SpvOpReservedWritePipe = 277,
-    SpvOpReserveReadPipePackets = 278,
-    SpvOpReserveWritePipePackets = 279,
-    SpvOpCommitReadPipe = 280,
-    SpvOpCommitWritePipe = 281,
-    SpvOpIsValidReserveId = 282,
-    SpvOpGetNumPipePackets = 283,
-    SpvOpGetMaxPipePackets = 284,
-    SpvOpGroupReserveReadPipePackets = 285,
-    SpvOpGroupReserveWritePipePackets = 286,
-    SpvOpGroupCommitReadPipe = 287,
-    SpvOpGroupCommitWritePipe = 288,
-    SpvOpEnqueueMarker = 291,
-    SpvOpEnqueueKernel = 292,
-    SpvOpGetKernelNDrangeSubGroupCount = 293,
-    SpvOpGetKernelNDrangeMaxSubGroupSize = 294,
-    SpvOpGetKernelWorkGroupSize = 295,
-    SpvOpGetKernelPreferredWorkGroupSizeMultiple = 296,
-    SpvOpRetainEvent = 297,
-    SpvOpReleaseEvent = 298,
-    SpvOpCreateUserEvent = 299,
-    SpvOpIsValidEvent = 300,
-    SpvOpSetUserEventStatus = 301,
-    SpvOpCaptureEventProfilingInfo = 302,
-    SpvOpGetDefaultQueue = 303,
-    SpvOpBuildNDRange = 304,
-    SpvOpImageSparseSampleImplicitLod = 305,
-    SpvOpImageSparseSampleExplicitLod = 306,
-    SpvOpImageSparseSampleDrefImplicitLod = 307,
-    SpvOpImageSparseSampleDrefExplicitLod = 308,
-    SpvOpImageSparseSampleProjImplicitLod = 309,
-    SpvOpImageSparseSampleProjExplicitLod = 310,
-    SpvOpImageSparseSampleProjDrefImplicitLod = 311,
-    SpvOpImageSparseSampleProjDrefExplicitLod = 312,
-    SpvOpImageSparseFetch = 313,
-    SpvOpImageSparseGather = 314,
-    SpvOpImageSparseDrefGather = 315,
-    SpvOpImageSparseTexelsResident = 316,
-    SpvOpNoLine = 317,
-    SpvOpAtomicFlagTestAndSet = 318,
-    SpvOpAtomicFlagClear = 319,
-    SpvOpImageSparseRead = 320,
-    SpvOpSizeOf = 321,
-    SpvOpTypePipeStorage = 322,
-    SpvOpConstantPipeStorage = 323,
-    SpvOpCreatePipeFromPipeStorage = 324,
-    SpvOpGetKernelLocalSizeForSubgroupCount = 325,
-    SpvOpGetKernelMaxNumSubgroups = 326,
-    SpvOpTypeNamedBarrier = 327,
-    SpvOpNamedBarrierInitialize = 328,
-    SpvOpMemoryNamedBarrier = 329,
-    SpvOpModuleProcessed = 330,
-    SpvOpExecutionModeId = 331,
-    SpvOpDecorateId = 332,
-    SpvOpGroupNonUniformElect = 333,
-    SpvOpGroupNonUniformAll = 334,
-    SpvOpGroupNonUniformAny = 335,
-    SpvOpGroupNonUniformAllEqual = 336,
-    SpvOpGroupNonUniformBroadcast = 337,
-    SpvOpGroupNonUniformBroadcastFirst = 338,
-    SpvOpGroupNonUniformBallot = 339,
-    SpvOpGroupNonUniformInverseBallot = 340,
-    SpvOpGroupNonUniformBallotBitExtract = 341,
-    SpvOpGroupNonUniformBallotBitCount = 342,
-    SpvOpGroupNonUniformBallotFindLSB = 343,
-    SpvOpGroupNonUniformBallotFindMSB = 344,
-    SpvOpGroupNonUniformShuffle = 345,
-    SpvOpGroupNonUniformShuffleXor = 346,
-    SpvOpGroupNonUniformShuffleUp = 347,
-    SpvOpGroupNonUniformShuffleDown = 348,
-    SpvOpGroupNonUniformIAdd = 349,
-    SpvOpGroupNonUniformFAdd = 350,
-    SpvOpGroupNonUniformIMul = 351,
-    SpvOpGroupNonUniformFMul = 352,
-    SpvOpGroupNonUniformSMin = 353,
-    SpvOpGroupNonUniformUMin = 354,
-    SpvOpGroupNonUniformFMin = 355,
-    SpvOpGroupNonUniformSMax = 356,
-    SpvOpGroupNonUniformUMax = 357,
-    SpvOpGroupNonUniformFMax = 358,
-    SpvOpGroupNonUniformBitwiseAnd = 359,
-    SpvOpGroupNonUniformBitwiseOr = 360,
-    SpvOpGroupNonUniformBitwiseXor = 361,
-    SpvOpGroupNonUniformLogicalAnd = 362,
-    SpvOpGroupNonUniformLogicalOr = 363,
-    SpvOpGroupNonUniformLogicalXor = 364,
-    SpvOpGroupNonUniformQuadBroadcast = 365,
-    SpvOpGroupNonUniformQuadSwap = 366,
-    SpvOpCopyLogical = 400,
-    SpvOpPtrEqual = 401,
-    SpvOpPtrNotEqual = 402,
-    SpvOpPtrDiff = 403,
-    SpvOpTerminateInvocation = 4416,
-    SpvOpSubgroupBallotKHR = 4421,
-    SpvOpSubgroupFirstInvocationKHR = 4422,
-    SpvOpSubgroupAllKHR = 4428,
-    SpvOpSubgroupAnyKHR = 4429,
-    SpvOpSubgroupAllEqualKHR = 4430,
-    SpvOpSubgroupReadInvocationKHR = 4432,
-    SpvOpTraceRayKHR = 4445,
-    SpvOpExecuteCallableKHR = 4446,
-    SpvOpConvertUToAccelerationStructureKHR = 4447,
-    SpvOpIgnoreIntersectionKHR = 4448,
-    SpvOpTerminateRayKHR = 4449,
-    SpvOpTypeRayQueryKHR = 4472,
-    SpvOpRayQueryInitializeKHR = 4473,
-    SpvOpRayQueryTerminateKHR = 4474,
-    SpvOpRayQueryGenerateIntersectionKHR = 4475,
-    SpvOpRayQueryConfirmIntersectionKHR = 4476,
-    SpvOpRayQueryProceedKHR = 4477,
-    SpvOpRayQueryGetIntersectionTypeKHR = 4479,
-    SpvOpGroupIAddNonUniformAMD = 5000,
-    SpvOpGroupFAddNonUniformAMD = 5001,
-    SpvOpGroupFMinNonUniformAMD = 5002,
-    SpvOpGroupUMinNonUniformAMD = 5003,
-    SpvOpGroupSMinNonUniformAMD = 5004,
-    SpvOpGroupFMaxNonUniformAMD = 5005,
-    SpvOpGroupUMaxNonUniformAMD = 5006,
-    SpvOpGroupSMaxNonUniformAMD = 5007,
-    SpvOpFragmentMaskFetchAMD = 5011,
-    SpvOpFragmentFetchAMD = 5012,
-    SpvOpReadClockKHR = 5056,
-    SpvOpImageSampleFootprintNV = 5283,
-    SpvOpGroupNonUniformPartitionNV = 5296,
-    SpvOpWritePackedPrimitiveIndices4x8NV = 5299,
-    SpvOpReportIntersectionKHR = 5334,
-    SpvOpReportIntersectionNV = 5334,
-    SpvOpIgnoreIntersectionNV = 5335,
-    SpvOpTerminateRayNV = 5336,
-    SpvOpTraceNV = 5337,
-    SpvOpTypeAccelerationStructureKHR = 5341,
-    SpvOpTypeAccelerationStructureNV = 5341,
-    SpvOpExecuteCallableNV = 5344,
-    SpvOpTypeCooperativeMatrixNV = 5358,
-    SpvOpCooperativeMatrixLoadNV = 5359,
-    SpvOpCooperativeMatrixStoreNV = 5360,
-    SpvOpCooperativeMatrixMulAddNV = 5361,
-    SpvOpCooperativeMatrixLengthNV = 5362,
-    SpvOpBeginInvocationInterlockEXT = 5364,
-    SpvOpEndInvocationInterlockEXT = 5365,
-    SpvOpDemoteToHelperInvocationEXT = 5380,
-    SpvOpIsHelperInvocationEXT = 5381,
-    SpvOpSubgroupShuffleINTEL = 5571,
-    SpvOpSubgroupShuffleDownINTEL = 5572,
-    SpvOpSubgroupShuffleUpINTEL = 5573,
-    SpvOpSubgroupShuffleXorINTEL = 5574,
-    SpvOpSubgroupBlockReadINTEL = 5575,
-    SpvOpSubgroupBlockWriteINTEL = 5576,
-    SpvOpSubgroupImageBlockReadINTEL = 5577,
-    SpvOpSubgroupImageBlockWriteINTEL = 5578,
-    SpvOpSubgroupImageMediaBlockReadINTEL = 5580,
-    SpvOpSubgroupImageMediaBlockWriteINTEL = 5581,
-    SpvOpUCountLeadingZerosINTEL = 5585,
-    SpvOpUCountTrailingZerosINTEL = 5586,
-    SpvOpAbsISubINTEL = 5587,
-    SpvOpAbsUSubINTEL = 5588,
-    SpvOpIAddSatINTEL = 5589,
-    SpvOpUAddSatINTEL = 5590,
-    SpvOpIAverageINTEL = 5591,
-    SpvOpUAverageINTEL = 5592,
-    SpvOpIAverageRoundedINTEL = 5593,
-    SpvOpUAverageRoundedINTEL = 5594,
-    SpvOpISubSatINTEL = 5595,
-    SpvOpUSubSatINTEL = 5596,
-    SpvOpIMul32x16INTEL = 5597,
-    SpvOpUMul32x16INTEL = 5598,
-    SpvOpFunctionPointerINTEL = 5600,
-    SpvOpFunctionPointerCallINTEL = 5601,
-    SpvOpDecorateString = 5632,
-    SpvOpDecorateStringGOOGLE = 5632,
-    SpvOpMemberDecorateString = 5633,
-    SpvOpMemberDecorateStringGOOGLE = 5633,
-    SpvOpVmeImageINTEL = 5699,
-    SpvOpTypeVmeImageINTEL = 5700,
-    SpvOpTypeAvcImePayloadINTEL = 5701,
-    SpvOpTypeAvcRefPayloadINTEL = 5702,
-    SpvOpTypeAvcSicPayloadINTEL = 5703,
-    SpvOpTypeAvcMcePayloadINTEL = 5704,
-    SpvOpTypeAvcMceResultINTEL = 5705,
-    SpvOpTypeAvcImeResultINTEL = 5706,
-    SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
-    SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
-    SpvOpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
-    SpvOpTypeAvcImeDualReferenceStreaminINTEL = 5710,
-    SpvOpTypeAvcRefResultINTEL = 5711,
-    SpvOpTypeAvcSicResultINTEL = 5712,
-    SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
-    SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
-    SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
-    SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
-    SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
-    SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
-    SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
-    SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
-    SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
-    SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
-    SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
-    SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
-    SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
-    SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
-    SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
-    SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
-    SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
-    SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
-    SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
-    SpvOpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
-    SpvOpSubgroupAvcMceConvertToImeResultINTEL = 5733,
-    SpvOpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
-    SpvOpSubgroupAvcMceConvertToRefResultINTEL = 5735,
-    SpvOpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
-    SpvOpSubgroupAvcMceConvertToSicResultINTEL = 5737,
-    SpvOpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
-    SpvOpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
-    SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
-    SpvOpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
-    SpvOpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
-    SpvOpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
-    SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
-    SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
-    SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
-    SpvOpSubgroupAvcImeInitializeINTEL = 5747,
-    SpvOpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
-    SpvOpSubgroupAvcImeSetDualReferenceINTEL = 5749,
-    SpvOpSubgroupAvcImeRefWindowSizeINTEL = 5750,
-    SpvOpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
-    SpvOpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
-    SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
-    SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
-    SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
-    SpvOpSubgroupAvcImeSetWeightedSadINTEL = 5756,
-    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
-    SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
-    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
-    SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
-    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
-    SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
-    SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
-    SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
-    SpvOpSubgroupAvcImeConvertToMceResultINTEL = 5765,
-    SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
-    SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
-    SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
-    SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
-    SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
-    SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
-    SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
-    SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
-    SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
-    SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
-    SpvOpSubgroupAvcImeGetBorderReachedINTEL = 5776,
-    SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
-    SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
-    SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
-    SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
-    SpvOpSubgroupAvcFmeInitializeINTEL = 5781,
-    SpvOpSubgroupAvcBmeInitializeINTEL = 5782,
-    SpvOpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
-    SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
-    SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
-    SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
-    SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
-    SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
-    SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
-    SpvOpSubgroupAvcRefConvertToMceResultINTEL = 5790,
-    SpvOpSubgroupAvcSicInitializeINTEL = 5791,
-    SpvOpSubgroupAvcSicConfigureSkcINTEL = 5792,
-    SpvOpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
-    SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
-    SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
-    SpvOpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
-    SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
-    SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
-    SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
-    SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
-    SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
-    SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
-    SpvOpSubgroupAvcSicEvaluateIpeINTEL = 5803,
-    SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
-    SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
-    SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
-    SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
-    SpvOpSubgroupAvcSicConvertToMceResultINTEL = 5808,
-    SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
-    SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
-    SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
-    SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
-    SpvOpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
-    SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
-    SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
-    SpvOpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
-    SpvOpLoopControlINTEL = 5887,
-    SpvOpReadPipeBlockingINTEL = 5946,
-    SpvOpWritePipeBlockingINTEL = 5947,
-    SpvOpFPGARegINTEL = 5949,
-    SpvOpRayQueryGetRayTMinKHR = 6016,
-    SpvOpRayQueryGetRayFlagsKHR = 6017,
-    SpvOpRayQueryGetIntersectionTKHR = 6018,
-    SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
-    SpvOpRayQueryGetIntersectionInstanceIdKHR = 6020,
-    SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
-    SpvOpRayQueryGetIntersectionGeometryIndexKHR = 6022,
-    SpvOpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
-    SpvOpRayQueryGetIntersectionBarycentricsKHR = 6024,
-    SpvOpRayQueryGetIntersectionFrontFaceKHR = 6025,
-    SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
-    SpvOpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
-    SpvOpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
-    SpvOpRayQueryGetWorldRayDirectionKHR = 6029,
-    SpvOpRayQueryGetWorldRayOriginKHR = 6030,
-    SpvOpRayQueryGetIntersectionObjectToWorldKHR = 6031,
-    SpvOpRayQueryGetIntersectionWorldToObjectKHR = 6032,
-    SpvOpAtomicFAddEXT = 6035,
-    SpvOpMax = 0x7fffffff,
+  SpvOpNop = 0,
+  SpvOpUndef = 1,
+  SpvOpSourceContinued = 2,
+  SpvOpSource = 3,
+  SpvOpSourceExtension = 4,
+  SpvOpName = 5,
+  SpvOpMemberName = 6,
+  SpvOpString = 7,
+  SpvOpLine = 8,
+  SpvOpExtension = 10,
+  SpvOpExtInstImport = 11,
+  SpvOpExtInst = 12,
+  SpvOpMemoryModel = 14,
+  SpvOpEntryPoint = 15,
+  SpvOpExecutionMode = 16,
+  SpvOpCapability = 17,
+  SpvOpTypeVoid = 19,
+  SpvOpTypeBool = 20,
+  SpvOpTypeInt = 21,
+  SpvOpTypeFloat = 22,
+  SpvOpTypeVector = 23,
+  SpvOpTypeMatrix = 24,
+  SpvOpTypeImage = 25,
+  SpvOpTypeSampler = 26,
+  SpvOpTypeSampledImage = 27,
+  SpvOpTypeArray = 28,
+  SpvOpTypeRuntimeArray = 29,
+  SpvOpTypeStruct = 30,
+  SpvOpTypeOpaque = 31,
+  SpvOpTypePointer = 32,
+  SpvOpTypeFunction = 33,
+  SpvOpTypeEvent = 34,
+  SpvOpTypeDeviceEvent = 35,
+  SpvOpTypeReserveId = 36,
+  SpvOpTypeQueue = 37,
+  SpvOpTypePipe = 38,
+  SpvOpTypeForwardPointer = 39,
+  SpvOpConstantTrue = 41,
+  SpvOpConstantFalse = 42,
+  SpvOpConstant = 43,
+  SpvOpConstantComposite = 44,
+  SpvOpConstantSampler = 45,
+  SpvOpConstantNull = 46,
+  SpvOpSpecConstantTrue = 48,
+  SpvOpSpecConstantFalse = 49,
+  SpvOpSpecConstant = 50,
+  SpvOpSpecConstantComposite = 51,
+  SpvOpSpecConstantOp = 52,
+  SpvOpFunction = 54,
+  SpvOpFunctionParameter = 55,
+  SpvOpFunctionEnd = 56,
+  SpvOpFunctionCall = 57,
+  SpvOpVariable = 59,
+  SpvOpImageTexelPointer = 60,
+  SpvOpLoad = 61,
+  SpvOpStore = 62,
+  SpvOpCopyMemory = 63,
+  SpvOpCopyMemorySized = 64,
+  SpvOpAccessChain = 65,
+  SpvOpInBoundsAccessChain = 66,
+  SpvOpPtrAccessChain = 67,
+  SpvOpArrayLength = 68,
+  SpvOpGenericPtrMemSemantics = 69,
+  SpvOpInBoundsPtrAccessChain = 70,
+  SpvOpDecorate = 71,
+  SpvOpMemberDecorate = 72,
+  SpvOpDecorationGroup = 73,
+  SpvOpGroupDecorate = 74,
+  SpvOpGroupMemberDecorate = 75,
+  SpvOpVectorExtractDynamic = 77,
+  SpvOpVectorInsertDynamic = 78,
+  SpvOpVectorShuffle = 79,
+  SpvOpCompositeConstruct = 80,
+  SpvOpCompositeExtract = 81,
+  SpvOpCompositeInsert = 82,
+  SpvOpCopyObject = 83,
+  SpvOpTranspose = 84,
+  SpvOpSampledImage = 86,
+  SpvOpImageSampleImplicitLod = 87,
+  SpvOpImageSampleExplicitLod = 88,
+  SpvOpImageSampleDrefImplicitLod = 89,
+  SpvOpImageSampleDrefExplicitLod = 90,
+  SpvOpImageSampleProjImplicitLod = 91,
+  SpvOpImageSampleProjExplicitLod = 92,
+  SpvOpImageSampleProjDrefImplicitLod = 93,
+  SpvOpImageSampleProjDrefExplicitLod = 94,
+  SpvOpImageFetch = 95,
+  SpvOpImageGather = 96,
+  SpvOpImageDrefGather = 97,
+  SpvOpImageRead = 98,
+  SpvOpImageWrite = 99,
+  SpvOpImage = 100,
+  SpvOpImageQueryFormat = 101,
+  SpvOpImageQueryOrder = 102,
+  SpvOpImageQuerySizeLod = 103,
+  SpvOpImageQuerySize = 104,
+  SpvOpImageQueryLod = 105,
+  SpvOpImageQueryLevels = 106,
+  SpvOpImageQuerySamples = 107,
+  SpvOpConvertFToU = 109,
+  SpvOpConvertFToS = 110,
+  SpvOpConvertSToF = 111,
+  SpvOpConvertUToF = 112,
+  SpvOpUConvert = 113,
+  SpvOpSConvert = 114,
+  SpvOpFConvert = 115,
+  SpvOpQuantizeToF16 = 116,
+  SpvOpConvertPtrToU = 117,
+  SpvOpSatConvertSToU = 118,
+  SpvOpSatConvertUToS = 119,
+  SpvOpConvertUToPtr = 120,
+  SpvOpPtrCastToGeneric = 121,
+  SpvOpGenericCastToPtr = 122,
+  SpvOpGenericCastToPtrExplicit = 123,
+  SpvOpBitcast = 124,
+  SpvOpSNegate = 126,
+  SpvOpFNegate = 127,
+  SpvOpIAdd = 128,
+  SpvOpFAdd = 129,
+  SpvOpISub = 130,
+  SpvOpFSub = 131,
+  SpvOpIMul = 132,
+  SpvOpFMul = 133,
+  SpvOpUDiv = 134,
+  SpvOpSDiv = 135,
+  SpvOpFDiv = 136,
+  SpvOpUMod = 137,
+  SpvOpSRem = 138,
+  SpvOpSMod = 139,
+  SpvOpFRem = 140,
+  SpvOpFMod = 141,
+  SpvOpVectorTimesScalar = 142,
+  SpvOpMatrixTimesScalar = 143,
+  SpvOpVectorTimesMatrix = 144,
+  SpvOpMatrixTimesVector = 145,
+  SpvOpMatrixTimesMatrix = 146,
+  SpvOpOuterProduct = 147,
+  SpvOpDot = 148,
+  SpvOpIAddCarry = 149,
+  SpvOpISubBorrow = 150,
+  SpvOpUMulExtended = 151,
+  SpvOpSMulExtended = 152,
+  SpvOpAny = 154,
+  SpvOpAll = 155,
+  SpvOpIsNan = 156,
+  SpvOpIsInf = 157,
+  SpvOpIsFinite = 158,
+  SpvOpIsNormal = 159,
+  SpvOpSignBitSet = 160,
+  SpvOpLessOrGreater = 161,
+  SpvOpOrdered = 162,
+  SpvOpUnordered = 163,
+  SpvOpLogicalEqual = 164,
+  SpvOpLogicalNotEqual = 165,
+  SpvOpLogicalOr = 166,
+  SpvOpLogicalAnd = 167,
+  SpvOpLogicalNot = 168,
+  SpvOpSelect = 169,
+  SpvOpIEqual = 170,
+  SpvOpINotEqual = 171,
+  SpvOpUGreaterThan = 172,
+  SpvOpSGreaterThan = 173,
+  SpvOpUGreaterThanEqual = 174,
+  SpvOpSGreaterThanEqual = 175,
+  SpvOpULessThan = 176,
+  SpvOpSLessThan = 177,
+  SpvOpULessThanEqual = 178,
+  SpvOpSLessThanEqual = 179,
+  SpvOpFOrdEqual = 180,
+  SpvOpFUnordEqual = 181,
+  SpvOpFOrdNotEqual = 182,
+  SpvOpFUnordNotEqual = 183,
+  SpvOpFOrdLessThan = 184,
+  SpvOpFUnordLessThan = 185,
+  SpvOpFOrdGreaterThan = 186,
+  SpvOpFUnordGreaterThan = 187,
+  SpvOpFOrdLessThanEqual = 188,
+  SpvOpFUnordLessThanEqual = 189,
+  SpvOpFOrdGreaterThanEqual = 190,
+  SpvOpFUnordGreaterThanEqual = 191,
+  SpvOpShiftRightLogical = 194,
+  SpvOpShiftRightArithmetic = 195,
+  SpvOpShiftLeftLogical = 196,
+  SpvOpBitwiseOr = 197,
+  SpvOpBitwiseXor = 198,
+  SpvOpBitwiseAnd = 199,
+  SpvOpNot = 200,
+  SpvOpBitFieldInsert = 201,
+  SpvOpBitFieldSExtract = 202,
+  SpvOpBitFieldUExtract = 203,
+  SpvOpBitReverse = 204,
+  SpvOpBitCount = 205,
+  SpvOpDPdx = 207,
+  SpvOpDPdy = 208,
+  SpvOpFwidth = 209,
+  SpvOpDPdxFine = 210,
+  SpvOpDPdyFine = 211,
+  SpvOpFwidthFine = 212,
+  SpvOpDPdxCoarse = 213,
+  SpvOpDPdyCoarse = 214,
+  SpvOpFwidthCoarse = 215,
+  SpvOpEmitVertex = 218,
+  SpvOpEndPrimitive = 219,
+  SpvOpEmitStreamVertex = 220,
+  SpvOpEndStreamPrimitive = 221,
+  SpvOpControlBarrier = 224,
+  SpvOpMemoryBarrier = 225,
+  SpvOpAtomicLoad = 227,
+  SpvOpAtomicStore = 228,
+  SpvOpAtomicExchange = 229,
+  SpvOpAtomicCompareExchange = 230,
+  SpvOpAtomicCompareExchangeWeak = 231,
+  SpvOpAtomicIIncrement = 232,
+  SpvOpAtomicIDecrement = 233,
+  SpvOpAtomicIAdd = 234,
+  SpvOpAtomicISub = 235,
+  SpvOpAtomicSMin = 236,
+  SpvOpAtomicUMin = 237,
+  SpvOpAtomicSMax = 238,
+  SpvOpAtomicUMax = 239,
+  SpvOpAtomicAnd = 240,
+  SpvOpAtomicOr = 241,
+  SpvOpAtomicXor = 242,
+  SpvOpPhi = 245,
+  SpvOpLoopMerge = 246,
+  SpvOpSelectionMerge = 247,
+  SpvOpLabel = 248,
+  SpvOpBranch = 249,
+  SpvOpBranchConditional = 250,
+  SpvOpSwitch = 251,
+  SpvOpKill = 252,
+  SpvOpReturn = 253,
+  SpvOpReturnValue = 254,
+  SpvOpUnreachable = 255,
+  SpvOpLifetimeStart = 256,
+  SpvOpLifetimeStop = 257,
+  SpvOpGroupAsyncCopy = 259,
+  SpvOpGroupWaitEvents = 260,
+  SpvOpGroupAll = 261,
+  SpvOpGroupAny = 262,
+  SpvOpGroupBroadcast = 263,
+  SpvOpGroupIAdd = 264,
+  SpvOpGroupFAdd = 265,
+  SpvOpGroupFMin = 266,
+  SpvOpGroupUMin = 267,
+  SpvOpGroupSMin = 268,
+  SpvOpGroupFMax = 269,
+  SpvOpGroupUMax = 270,
+  SpvOpGroupSMax = 271,
+  SpvOpReadPipe = 274,
+  SpvOpWritePipe = 275,
+  SpvOpReservedReadPipe = 276,
+  SpvOpReservedWritePipe = 277,
+  SpvOpReserveReadPipePackets = 278,
+  SpvOpReserveWritePipePackets = 279,
+  SpvOpCommitReadPipe = 280,
+  SpvOpCommitWritePipe = 281,
+  SpvOpIsValidReserveId = 282,
+  SpvOpGetNumPipePackets = 283,
+  SpvOpGetMaxPipePackets = 284,
+  SpvOpGroupReserveReadPipePackets = 285,
+  SpvOpGroupReserveWritePipePackets = 286,
+  SpvOpGroupCommitReadPipe = 287,
+  SpvOpGroupCommitWritePipe = 288,
+  SpvOpEnqueueMarker = 291,
+  SpvOpEnqueueKernel = 292,
+  SpvOpGetKernelNDrangeSubGroupCount = 293,
+  SpvOpGetKernelNDrangeMaxSubGroupSize = 294,
+  SpvOpGetKernelWorkGroupSize = 295,
+  SpvOpGetKernelPreferredWorkGroupSizeMultiple = 296,
+  SpvOpRetainEvent = 297,
+  SpvOpReleaseEvent = 298,
+  SpvOpCreateUserEvent = 299,
+  SpvOpIsValidEvent = 300,
+  SpvOpSetUserEventStatus = 301,
+  SpvOpCaptureEventProfilingInfo = 302,
+  SpvOpGetDefaultQueue = 303,
+  SpvOpBuildNDRange = 304,
+  SpvOpImageSparseSampleImplicitLod = 305,
+  SpvOpImageSparseSampleExplicitLod = 306,
+  SpvOpImageSparseSampleDrefImplicitLod = 307,
+  SpvOpImageSparseSampleDrefExplicitLod = 308,
+  SpvOpImageSparseSampleProjImplicitLod = 309,
+  SpvOpImageSparseSampleProjExplicitLod = 310,
+  SpvOpImageSparseSampleProjDrefImplicitLod = 311,
+  SpvOpImageSparseSampleProjDrefExplicitLod = 312,
+  SpvOpImageSparseFetch = 313,
+  SpvOpImageSparseGather = 314,
+  SpvOpImageSparseDrefGather = 315,
+  SpvOpImageSparseTexelsResident = 316,
+  SpvOpNoLine = 317,
+  SpvOpAtomicFlagTestAndSet = 318,
+  SpvOpAtomicFlagClear = 319,
+  SpvOpImageSparseRead = 320,
+  SpvOpSizeOf = 321,
+  SpvOpTypePipeStorage = 322,
+  SpvOpConstantPipeStorage = 323,
+  SpvOpCreatePipeFromPipeStorage = 324,
+  SpvOpGetKernelLocalSizeForSubgroupCount = 325,
+  SpvOpGetKernelMaxNumSubgroups = 326,
+  SpvOpTypeNamedBarrier = 327,
+  SpvOpNamedBarrierInitialize = 328,
+  SpvOpMemoryNamedBarrier = 329,
+  SpvOpModuleProcessed = 330,
+  SpvOpExecutionModeId = 331,
+  SpvOpDecorateId = 332,
+  SpvOpGroupNonUniformElect = 333,
+  SpvOpGroupNonUniformAll = 334,
+  SpvOpGroupNonUniformAny = 335,
+  SpvOpGroupNonUniformAllEqual = 336,
+  SpvOpGroupNonUniformBroadcast = 337,
+  SpvOpGroupNonUniformBroadcastFirst = 338,
+  SpvOpGroupNonUniformBallot = 339,
+  SpvOpGroupNonUniformInverseBallot = 340,
+  SpvOpGroupNonUniformBallotBitExtract = 341,
+  SpvOpGroupNonUniformBallotBitCount = 342,
+  SpvOpGroupNonUniformBallotFindLSB = 343,
+  SpvOpGroupNonUniformBallotFindMSB = 344,
+  SpvOpGroupNonUniformShuffle = 345,
+  SpvOpGroupNonUniformShuffleXor = 346,
+  SpvOpGroupNonUniformShuffleUp = 347,
+  SpvOpGroupNonUniformShuffleDown = 348,
+  SpvOpGroupNonUniformIAdd = 349,
+  SpvOpGroupNonUniformFAdd = 350,
+  SpvOpGroupNonUniformIMul = 351,
+  SpvOpGroupNonUniformFMul = 352,
+  SpvOpGroupNonUniformSMin = 353,
+  SpvOpGroupNonUniformUMin = 354,
+  SpvOpGroupNonUniformFMin = 355,
+  SpvOpGroupNonUniformSMax = 356,
+  SpvOpGroupNonUniformUMax = 357,
+  SpvOpGroupNonUniformFMax = 358,
+  SpvOpGroupNonUniformBitwiseAnd = 359,
+  SpvOpGroupNonUniformBitwiseOr = 360,
+  SpvOpGroupNonUniformBitwiseXor = 361,
+  SpvOpGroupNonUniformLogicalAnd = 362,
+  SpvOpGroupNonUniformLogicalOr = 363,
+  SpvOpGroupNonUniformLogicalXor = 364,
+  SpvOpGroupNonUniformQuadBroadcast = 365,
+  SpvOpGroupNonUniformQuadSwap = 366,
+  SpvOpCopyLogical = 400,
+  SpvOpPtrEqual = 401,
+  SpvOpPtrNotEqual = 402,
+  SpvOpPtrDiff = 403,
+  SpvOpColorAttachmentReadEXT = 4160,
+  SpvOpDepthAttachmentReadEXT = 4161,
+  SpvOpStencilAttachmentReadEXT = 4162,
+  SpvOpTerminateInvocation = 4416,
+  SpvOpSubgroupBallotKHR = 4421,
+  SpvOpSubgroupFirstInvocationKHR = 4422,
+  SpvOpSubgroupAllKHR = 4428,
+  SpvOpSubgroupAnyKHR = 4429,
+  SpvOpSubgroupAllEqualKHR = 4430,
+  SpvOpGroupNonUniformRotateKHR = 4431,
+  SpvOpSubgroupReadInvocationKHR = 4432,
+  SpvOpTraceRayKHR = 4445,
+  SpvOpExecuteCallableKHR = 4446,
+  SpvOpConvertUToAccelerationStructureKHR = 4447,
+  SpvOpIgnoreIntersectionKHR = 4448,
+  SpvOpTerminateRayKHR = 4449,
+  SpvOpSDot = 4450,
+  SpvOpSDotKHR = 4450,
+  SpvOpUDot = 4451,
+  SpvOpUDotKHR = 4451,
+  SpvOpSUDot = 4452,
+  SpvOpSUDotKHR = 4452,
+  SpvOpSDotAccSat = 4453,
+  SpvOpSDotAccSatKHR = 4453,
+  SpvOpUDotAccSat = 4454,
+  SpvOpUDotAccSatKHR = 4454,
+  SpvOpSUDotAccSat = 4455,
+  SpvOpSUDotAccSatKHR = 4455,
+  SpvOpTypeCooperativeMatrixKHR = 4456,
+  SpvOpCooperativeMatrixLoadKHR = 4457,
+  SpvOpCooperativeMatrixStoreKHR = 4458,
+  SpvOpCooperativeMatrixMulAddKHR = 4459,
+  SpvOpCooperativeMatrixLengthKHR = 4460,
+  SpvOpTypeRayQueryKHR = 4472,
+  SpvOpRayQueryInitializeKHR = 4473,
+  SpvOpRayQueryTerminateKHR = 4474,
+  SpvOpRayQueryGenerateIntersectionKHR = 4475,
+  SpvOpRayQueryConfirmIntersectionKHR = 4476,
+  SpvOpRayQueryProceedKHR = 4477,
+  SpvOpRayQueryGetIntersectionTypeKHR = 4479,
+  SpvOpImageSampleWeightedQCOM = 4480,
+  SpvOpImageBoxFilterQCOM = 4481,
+  SpvOpImageBlockMatchSSDQCOM = 4482,
+  SpvOpImageBlockMatchSADQCOM = 4483,
+  SpvOpGroupIAddNonUniformAMD = 5000,
+  SpvOpGroupFAddNonUniformAMD = 5001,
+  SpvOpGroupFMinNonUniformAMD = 5002,
+  SpvOpGroupUMinNonUniformAMD = 5003,
+  SpvOpGroupSMinNonUniformAMD = 5004,
+  SpvOpGroupFMaxNonUniformAMD = 5005,
+  SpvOpGroupUMaxNonUniformAMD = 5006,
+  SpvOpGroupSMaxNonUniformAMD = 5007,
+  SpvOpFragmentMaskFetchAMD = 5011,
+  SpvOpFragmentFetchAMD = 5012,
+  SpvOpReadClockKHR = 5056,
+  SpvOpHitObjectRecordHitMotionNV = 5249,
+  SpvOpHitObjectRecordHitWithIndexMotionNV = 5250,
+  SpvOpHitObjectRecordMissMotionNV = 5251,
+  SpvOpHitObjectGetWorldToObjectNV = 5252,
+  SpvOpHitObjectGetObjectToWorldNV = 5253,
+  SpvOpHitObjectGetObjectRayDirectionNV = 5254,
+  SpvOpHitObjectGetObjectRayOriginNV = 5255,
+  SpvOpHitObjectTraceRayMotionNV = 5256,
+  SpvOpHitObjectGetShaderRecordBufferHandleNV = 5257,
+  SpvOpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
+  SpvOpHitObjectRecordEmptyNV = 5259,
+  SpvOpHitObjectTraceRayNV = 5260,
+  SpvOpHitObjectRecordHitNV = 5261,
+  SpvOpHitObjectRecordHitWithIndexNV = 5262,
+  SpvOpHitObjectRecordMissNV = 5263,
+  SpvOpHitObjectExecuteShaderNV = 5264,
+  SpvOpHitObjectGetCurrentTimeNV = 5265,
+  SpvOpHitObjectGetAttributesNV = 5266,
+  SpvOpHitObjectGetHitKindNV = 5267,
+  SpvOpHitObjectGetPrimitiveIndexNV = 5268,
+  SpvOpHitObjectGetGeometryIndexNV = 5269,
+  SpvOpHitObjectGetInstanceIdNV = 5270,
+  SpvOpHitObjectGetInstanceCustomIndexNV = 5271,
+  SpvOpHitObjectGetWorldRayDirectionNV = 5272,
+  SpvOpHitObjectGetWorldRayOriginNV = 5273,
+  SpvOpHitObjectGetRayTMaxNV = 5274,
+  SpvOpHitObjectGetRayTMinNV = 5275,
+  SpvOpHitObjectIsEmptyNV = 5276,
+  SpvOpHitObjectIsHitNV = 5277,
+  SpvOpHitObjectIsMissNV = 5278,
+  SpvOpReorderThreadWithHitObjectNV = 5279,
+  SpvOpReorderThreadWithHintNV = 5280,
+  SpvOpTypeHitObjectNV = 5281,
+  SpvOpImageSampleFootprintNV = 5283,
+  SpvOpEmitMeshTasksEXT = 5294,
+  SpvOpSetMeshOutputsEXT = 5295,
+  SpvOpGroupNonUniformPartitionNV = 5296,
+  SpvOpWritePackedPrimitiveIndices4x8NV = 5299,
+  SpvOpReportIntersectionKHR = 5334,
+  SpvOpReportIntersectionNV = 5334,
+  SpvOpIgnoreIntersectionNV = 5335,
+  SpvOpTerminateRayNV = 5336,
+  SpvOpTraceNV = 5337,
+  SpvOpTraceMotionNV = 5338,
+  SpvOpTraceRayMotionNV = 5339,
+  SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
+  SpvOpTypeAccelerationStructureKHR = 5341,
+  SpvOpTypeAccelerationStructureNV = 5341,
+  SpvOpExecuteCallableNV = 5344,
+  SpvOpTypeCooperativeMatrixNV = 5358,
+  SpvOpCooperativeMatrixLoadNV = 5359,
+  SpvOpCooperativeMatrixStoreNV = 5360,
+  SpvOpCooperativeMatrixMulAddNV = 5361,
+  SpvOpCooperativeMatrixLengthNV = 5362,
+  SpvOpBeginInvocationInterlockEXT = 5364,
+  SpvOpEndInvocationInterlockEXT = 5365,
+  SpvOpDemoteToHelperInvocation = 5380,
+  SpvOpDemoteToHelperInvocationEXT = 5380,
+  SpvOpIsHelperInvocationEXT = 5381,
+  SpvOpConvertUToImageNV = 5391,
+  SpvOpConvertUToSamplerNV = 5392,
+  SpvOpConvertImageToUNV = 5393,
+  SpvOpConvertSamplerToUNV = 5394,
+  SpvOpConvertUToSampledImageNV = 5395,
+  SpvOpConvertSampledImageToUNV = 5396,
+  SpvOpSamplerImageAddressingModeNV = 5397,
+  SpvOpSubgroupShuffleINTEL = 5571,
+  SpvOpSubgroupShuffleDownINTEL = 5572,
+  SpvOpSubgroupShuffleUpINTEL = 5573,
+  SpvOpSubgroupShuffleXorINTEL = 5574,
+  SpvOpSubgroupBlockReadINTEL = 5575,
+  SpvOpSubgroupBlockWriteINTEL = 5576,
+  SpvOpSubgroupImageBlockReadINTEL = 5577,
+  SpvOpSubgroupImageBlockWriteINTEL = 5578,
+  SpvOpSubgroupImageMediaBlockReadINTEL = 5580,
+  SpvOpSubgroupImageMediaBlockWriteINTEL = 5581,
+  SpvOpUCountLeadingZerosINTEL = 5585,
+  SpvOpUCountTrailingZerosINTEL = 5586,
+  SpvOpAbsISubINTEL = 5587,
+  SpvOpAbsUSubINTEL = 5588,
+  SpvOpIAddSatINTEL = 5589,
+  SpvOpUAddSatINTEL = 5590,
+  SpvOpIAverageINTEL = 5591,
+  SpvOpUAverageINTEL = 5592,
+  SpvOpIAverageRoundedINTEL = 5593,
+  SpvOpUAverageRoundedINTEL = 5594,
+  SpvOpISubSatINTEL = 5595,
+  SpvOpUSubSatINTEL = 5596,
+  SpvOpIMul32x16INTEL = 5597,
+  SpvOpUMul32x16INTEL = 5598,
+  SpvOpConstantFunctionPointerINTEL = 5600,
+  SpvOpFunctionPointerCallINTEL = 5601,
+  SpvOpAsmTargetINTEL = 5609,
+  SpvOpAsmINTEL = 5610,
+  SpvOpAsmCallINTEL = 5611,
+  SpvOpAtomicFMinEXT = 5614,
+  SpvOpAtomicFMaxEXT = 5615,
+  SpvOpAssumeTrueKHR = 5630,
+  SpvOpExpectKHR = 5631,
+  SpvOpDecorateString = 5632,
+  SpvOpDecorateStringGOOGLE = 5632,
+  SpvOpMemberDecorateString = 5633,
+  SpvOpMemberDecorateStringGOOGLE = 5633,
+  SpvOpVmeImageINTEL = 5699,
+  SpvOpTypeVmeImageINTEL = 5700,
+  SpvOpTypeAvcImePayloadINTEL = 5701,
+  SpvOpTypeAvcRefPayloadINTEL = 5702,
+  SpvOpTypeAvcSicPayloadINTEL = 5703,
+  SpvOpTypeAvcMcePayloadINTEL = 5704,
+  SpvOpTypeAvcMceResultINTEL = 5705,
+  SpvOpTypeAvcImeResultINTEL = 5706,
+  SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
+  SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
+  SpvOpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
+  SpvOpTypeAvcImeDualReferenceStreaminINTEL = 5710,
+  SpvOpTypeAvcRefResultINTEL = 5711,
+  SpvOpTypeAvcSicResultINTEL = 5712,
+  SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
+  SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
+  SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
+  SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
+  SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
+  SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
+  SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
+  SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
+  SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
+  SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
+  SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
+  SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
+  SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
+  SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
+  SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
+  SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
+  SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
+  SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
+  SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
+  SpvOpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
+  SpvOpSubgroupAvcMceConvertToImeResultINTEL = 5733,
+  SpvOpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
+  SpvOpSubgroupAvcMceConvertToRefResultINTEL = 5735,
+  SpvOpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
+  SpvOpSubgroupAvcMceConvertToSicResultINTEL = 5737,
+  SpvOpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
+  SpvOpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
+  SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
+  SpvOpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
+  SpvOpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
+  SpvOpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
+  SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
+  SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
+  SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
+  SpvOpSubgroupAvcImeInitializeINTEL = 5747,
+  SpvOpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
+  SpvOpSubgroupAvcImeSetDualReferenceINTEL = 5749,
+  SpvOpSubgroupAvcImeRefWindowSizeINTEL = 5750,
+  SpvOpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
+  SpvOpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
+  SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
+  SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
+  SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
+  SpvOpSubgroupAvcImeSetWeightedSadINTEL = 5756,
+  SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
+  SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
+  SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
+  SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
+  SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
+  SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
+  SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
+  SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
+  SpvOpSubgroupAvcImeConvertToMceResultINTEL = 5765,
+  SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
+  SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
+  SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
+  SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
+  SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL =
+      5770,
+  SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL =
+      5771,
+  SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL =
+      5772,
+  SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL =
+      5773,
+  SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
+  SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL =
+      5775,
+  SpvOpSubgroupAvcImeGetBorderReachedINTEL = 5776,
+  SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
+  SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
+  SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
+  SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
+  SpvOpSubgroupAvcFmeInitializeINTEL = 5781,
+  SpvOpSubgroupAvcBmeInitializeINTEL = 5782,
+  SpvOpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
+  SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
+  SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
+  SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
+  SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
+  SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
+  SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
+  SpvOpSubgroupAvcRefConvertToMceResultINTEL = 5790,
+  SpvOpSubgroupAvcSicInitializeINTEL = 5791,
+  SpvOpSubgroupAvcSicConfigureSkcINTEL = 5792,
+  SpvOpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
+  SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
+  SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
+  SpvOpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
+  SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
+  SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
+  SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
+  SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
+  SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
+  SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
+  SpvOpSubgroupAvcSicEvaluateIpeINTEL = 5803,
+  SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
+  SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
+  SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
+  SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
+  SpvOpSubgroupAvcSicConvertToMceResultINTEL = 5808,
+  SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
+  SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
+  SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
+  SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
+  SpvOpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
+  SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
+  SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
+  SpvOpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
+  SpvOpVariableLengthArrayINTEL = 5818,
+  SpvOpSaveMemoryINTEL = 5819,
+  SpvOpRestoreMemoryINTEL = 5820,
+  SpvOpArbitraryFloatSinCosPiINTEL = 5840,
+  SpvOpArbitraryFloatCastINTEL = 5841,
+  SpvOpArbitraryFloatCastFromIntINTEL = 5842,
+  SpvOpArbitraryFloatCastToIntINTEL = 5843,
+  SpvOpArbitraryFloatAddINTEL = 5846,
+  SpvOpArbitraryFloatSubINTEL = 5847,
+  SpvOpArbitraryFloatMulINTEL = 5848,
+  SpvOpArbitraryFloatDivINTEL = 5849,
+  SpvOpArbitraryFloatGTINTEL = 5850,
+  SpvOpArbitraryFloatGEINTEL = 5851,
+  SpvOpArbitraryFloatLTINTEL = 5852,
+  SpvOpArbitraryFloatLEINTEL = 5853,
+  SpvOpArbitraryFloatEQINTEL = 5854,
+  SpvOpArbitraryFloatRecipINTEL = 5855,
+  SpvOpArbitraryFloatRSqrtINTEL = 5856,
+  SpvOpArbitraryFloatCbrtINTEL = 5857,
+  SpvOpArbitraryFloatHypotINTEL = 5858,
+  SpvOpArbitraryFloatSqrtINTEL = 5859,
+  SpvOpArbitraryFloatLogINTEL = 5860,
+  SpvOpArbitraryFloatLog2INTEL = 5861,
+  SpvOpArbitraryFloatLog10INTEL = 5862,
+  SpvOpArbitraryFloatLog1pINTEL = 5863,
+  SpvOpArbitraryFloatExpINTEL = 5864,
+  SpvOpArbitraryFloatExp2INTEL = 5865,
+  SpvOpArbitraryFloatExp10INTEL = 5866,
+  SpvOpArbitraryFloatExpm1INTEL = 5867,
+  SpvOpArbitraryFloatSinINTEL = 5868,
+  SpvOpArbitraryFloatCosINTEL = 5869,
+  SpvOpArbitraryFloatSinCosINTEL = 5870,
+  SpvOpArbitraryFloatSinPiINTEL = 5871,
+  SpvOpArbitraryFloatCosPiINTEL = 5872,
+  SpvOpArbitraryFloatASinINTEL = 5873,
+  SpvOpArbitraryFloatASinPiINTEL = 5874,
+  SpvOpArbitraryFloatACosINTEL = 5875,
+  SpvOpArbitraryFloatACosPiINTEL = 5876,
+  SpvOpArbitraryFloatATanINTEL = 5877,
+  SpvOpArbitraryFloatATanPiINTEL = 5878,
+  SpvOpArbitraryFloatATan2INTEL = 5879,
+  SpvOpArbitraryFloatPowINTEL = 5880,
+  SpvOpArbitraryFloatPowRINTEL = 5881,
+  SpvOpArbitraryFloatPowNINTEL = 5882,
+  SpvOpLoopControlINTEL = 5887,
+  SpvOpAliasDomainDeclINTEL = 5911,
+  SpvOpAliasScopeDeclINTEL = 5912,
+  SpvOpAliasScopeListDeclINTEL = 5913,
+  SpvOpFixedSqrtINTEL = 5923,
+  SpvOpFixedRecipINTEL = 5924,
+  SpvOpFixedRsqrtINTEL = 5925,
+  SpvOpFixedSinINTEL = 5926,
+  SpvOpFixedCosINTEL = 5927,
+  SpvOpFixedSinCosINTEL = 5928,
+  SpvOpFixedSinPiINTEL = 5929,
+  SpvOpFixedCosPiINTEL = 5930,
+  SpvOpFixedSinCosPiINTEL = 5931,
+  SpvOpFixedLogINTEL = 5932,
+  SpvOpFixedExpINTEL = 5933,
+  SpvOpPtrCastToCrossWorkgroupINTEL = 5934,
+  SpvOpCrossWorkgroupCastToPtrINTEL = 5938,
+  SpvOpReadPipeBlockingINTEL = 5946,
+  SpvOpWritePipeBlockingINTEL = 5947,
+  SpvOpFPGARegINTEL = 5949,
+  SpvOpRayQueryGetRayTMinKHR = 6016,
+  SpvOpRayQueryGetRayFlagsKHR = 6017,
+  SpvOpRayQueryGetIntersectionTKHR = 6018,
+  SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
+  SpvOpRayQueryGetIntersectionInstanceIdKHR = 6020,
+  SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
+  SpvOpRayQueryGetIntersectionGeometryIndexKHR = 6022,
+  SpvOpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
+  SpvOpRayQueryGetIntersectionBarycentricsKHR = 6024,
+  SpvOpRayQueryGetIntersectionFrontFaceKHR = 6025,
+  SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
+  SpvOpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
+  SpvOpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
+  SpvOpRayQueryGetWorldRayDirectionKHR = 6029,
+  SpvOpRayQueryGetWorldRayOriginKHR = 6030,
+  SpvOpRayQueryGetIntersectionObjectToWorldKHR = 6031,
+  SpvOpRayQueryGetIntersectionWorldToObjectKHR = 6032,
+  SpvOpAtomicFAddEXT = 6035,
+  SpvOpTypeBufferSurfaceINTEL = 6086,
+  SpvOpTypeStructContinuedINTEL = 6090,
+  SpvOpConstantCompositeContinuedINTEL = 6091,
+  SpvOpSpecConstantCompositeContinuedINTEL = 6092,
+  SpvOpConvertFToBF16INTEL = 6116,
+  SpvOpConvertBF16ToFINTEL = 6117,
+  SpvOpControlBarrierArriveINTEL = 6142,
+  SpvOpControlBarrierWaitINTEL = 6143,
+  SpvOpGroupIMulKHR = 6401,
+  SpvOpGroupFMulKHR = 6402,
+  SpvOpGroupBitwiseAndKHR = 6403,
+  SpvOpGroupBitwiseOrKHR = 6404,
+  SpvOpGroupBitwiseXorKHR = 6405,
+  SpvOpGroupLogicalAndKHR = 6406,
+  SpvOpGroupLogicalOrKHR = 6407,
+  SpvOpGroupLogicalXorKHR = 6408,
+  SpvOpMax = 0x7fffffff,
 } SpvOp;
 
 #ifdef SPV_ENABLE_UTILITY_CODE
-inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultType) {
-    *hasResult = *hasResultType = false;
-    switch (opcode) {
-    default: /* unknown opcode */ break;
-    case SpvOpNop: *hasResult = false; *hasResultType = false; break;
-    case SpvOpUndef: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSourceContinued: *hasResult = false; *hasResultType = false; break;
-    case SpvOpSource: *hasResult = false; *hasResultType = false; break;
-    case SpvOpSourceExtension: *hasResult = false; *hasResultType = false; break;
-    case SpvOpName: *hasResult = false; *hasResultType = false; break;
-    case SpvOpMemberName: *hasResult = false; *hasResultType = false; break;
-    case SpvOpString: *hasResult = true; *hasResultType = false; break;
-    case SpvOpLine: *hasResult = false; *hasResultType = false; break;
-    case SpvOpExtension: *hasResult = false; *hasResultType = false; break;
-    case SpvOpExtInstImport: *hasResult = true; *hasResultType = false; break;
-    case SpvOpExtInst: *hasResult = true; *hasResultType = true; break;
-    case SpvOpMemoryModel: *hasResult = false; *hasResultType = false; break;
-    case SpvOpEntryPoint: *hasResult = false; *hasResultType = false; break;
-    case SpvOpExecutionMode: *hasResult = false; *hasResultType = false; break;
-    case SpvOpCapability: *hasResult = false; *hasResultType = false; break;
-    case SpvOpTypeVoid: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeBool: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeInt: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeFloat: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeVector: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeMatrix: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeImage: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeSampler: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeArray: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeStruct: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeOpaque: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypePointer: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeFunction: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeEvent: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeReserveId: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeQueue: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypePipe: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
-    case SpvOpConstantTrue: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConstantFalse: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConstant: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConstantComposite: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConstantSampler: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConstantNull: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSpecConstant: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFunction: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFunctionParameter: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFunctionEnd: *hasResult = false; *hasResultType = false; break;
-    case SpvOpFunctionCall: *hasResult = true; *hasResultType = true; break;
-    case SpvOpVariable: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLoad: *hasResult = true; *hasResultType = true; break;
-    case SpvOpStore: *hasResult = false; *hasResultType = false; break;
-    case SpvOpCopyMemory: *hasResult = false; *hasResultType = false; break;
-    case SpvOpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
-    case SpvOpAccessChain: *hasResult = true; *hasResultType = true; break;
-    case SpvOpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
-    case SpvOpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
-    case SpvOpArrayLength: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
-    case SpvOpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDecorate: *hasResult = false; *hasResultType = false; break;
-    case SpvOpMemberDecorate: *hasResult = false; *hasResultType = false; break;
-    case SpvOpDecorationGroup: *hasResult = true; *hasResultType = false; break;
-    case SpvOpGroupDecorate: *hasResult = false; *hasResultType = false; break;
-    case SpvOpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
-    case SpvOpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
-    case SpvOpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
-    case SpvOpVectorShuffle: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCompositeExtract: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCompositeInsert: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCopyObject: *hasResult = true; *hasResultType = true; break;
-    case SpvOpTranspose: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSampledImage: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageFetch: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageGather: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageDrefGather: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageRead: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageWrite: *hasResult = false; *hasResultType = false; break;
-    case SpvOpImage: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageQuerySize: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageQueryLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConvertFToU: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConvertFToS: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConvertSToF: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConvertUToF: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUConvert: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSConvert: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFConvert: *hasResult = true; *hasResultType = true; break;
-    case SpvOpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
-    case SpvOpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
-    case SpvOpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitcast: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSNegate: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFNegate: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIAdd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFAdd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpISub: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFSub: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIMul: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFMul: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUDiv: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSDiv: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFDiv: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUMod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSRem: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSMod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFRem: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFMod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
-    case SpvOpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
-    case SpvOpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
-    case SpvOpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
-    case SpvOpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
-    case SpvOpOuterProduct: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDot: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIAddCarry: *hasResult = true; *hasResultType = true; break;
-    case SpvOpISubBorrow: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUMulExtended: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSMulExtended: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAny: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAll: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIsNan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIsInf: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIsFinite: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIsNormal: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSignBitSet: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLessOrGreater: *hasResult = true; *hasResultType = true; break;
-    case SpvOpOrdered: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUnordered: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLogicalEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLogicalOr: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLogicalAnd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLogicalNot: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSelect: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpINotEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpULessThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSLessThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpULessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFOrdEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFUnordEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
-    case SpvOpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
-    case SpvOpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitwiseOr: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitwiseXor: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpNot: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitReverse: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBitCount: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDPdx: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDPdy: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFwidth: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDPdxFine: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDPdyFine: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFwidthFine: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
-    case SpvOpEmitVertex: *hasResult = false; *hasResultType = false; break;
-    case SpvOpEndPrimitive: *hasResult = false; *hasResultType = false; break;
-    case SpvOpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
-    case SpvOpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
-    case SpvOpControlBarrier: *hasResult = false; *hasResultType = false; break;
-    case SpvOpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
-    case SpvOpAtomicLoad: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicStore: *hasResult = false; *hasResultType = false; break;
-    case SpvOpAtomicExchange: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicISub: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicSMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicUMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicSMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicUMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicAnd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicOr: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicXor: *hasResult = true; *hasResultType = true; break;
-    case SpvOpPhi: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLoopMerge: *hasResult = false; *hasResultType = false; break;
-    case SpvOpSelectionMerge: *hasResult = false; *hasResultType = false; break;
-    case SpvOpLabel: *hasResult = true; *hasResultType = false; break;
-    case SpvOpBranch: *hasResult = false; *hasResultType = false; break;
-    case SpvOpBranchConditional: *hasResult = false; *hasResultType = false; break;
-    case SpvOpSwitch: *hasResult = false; *hasResultType = false; break;
-    case SpvOpKill: *hasResult = false; *hasResultType = false; break;
-    case SpvOpReturn: *hasResult = false; *hasResultType = false; break;
-    case SpvOpReturnValue: *hasResult = false; *hasResultType = false; break;
-    case SpvOpUnreachable: *hasResult = false; *hasResultType = false; break;
-    case SpvOpLifetimeStart: *hasResult = false; *hasResultType = false; break;
-    case SpvOpLifetimeStop: *hasResult = false; *hasResultType = false; break;
-    case SpvOpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
-    case SpvOpGroupAll: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupAny: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupIAdd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupFAdd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupFMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupUMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupSMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupFMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupUMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupSMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpReadPipe: *hasResult = true; *hasResultType = true; break;
-    case SpvOpWritePipe: *hasResult = true; *hasResultType = true; break;
-    case SpvOpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
-    case SpvOpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
-    case SpvOpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
-    case SpvOpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
-    case SpvOpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
-    case SpvOpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
-    case SpvOpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
-    case SpvOpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
-    case SpvOpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRetainEvent: *hasResult = false; *hasResultType = false; break;
-    case SpvOpReleaseEvent: *hasResult = false; *hasResultType = false; break;
-    case SpvOpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIsValidEvent: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
-    case SpvOpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
-    case SpvOpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBuildNDRange: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseGather: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
-    case SpvOpNoLine: *hasResult = false; *hasResultType = false; break;
-    case SpvOpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
-    case SpvOpImageSparseRead: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSizeOf: *hasResult = true; *hasResultType = true; break;
-    case SpvOpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
-    case SpvOpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
-    case SpvOpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
-    case SpvOpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
-    case SpvOpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
-    case SpvOpModuleProcessed: *hasResult = false; *hasResultType = false; break;
-    case SpvOpExecutionModeId: *hasResult = false; *hasResultType = false; break;
-    case SpvOpDecorateId: *hasResult = false; *hasResultType = false; break;
-    case SpvOpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCopyLogical: *hasResult = true; *hasResultType = true; break;
-    case SpvOpPtrEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
-    case SpvOpPtrDiff: *hasResult = true; *hasResultType = true; break;
-    case SpvOpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
-    case SpvOpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;
-    case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case SpvOpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
-    case SpvOpReadClockKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
-    case SpvOpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
-    case SpvOpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
-    case SpvOpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
-    case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
-    case SpvOpTraceNV: *hasResult = false; *hasResultType = false; break;
-    case SpvOpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
-    case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
-    case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
-    case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
-    case SpvOpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
-    case SpvOpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
-    case SpvOpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
-    case SpvOpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
-    case SpvOpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break;
-    case SpvOpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case SpvOpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case SpvOpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case SpvOpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpDecorateString: *hasResult = false; *hasResultType = false; break;
-    case SpvOpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
-    case SpvOpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
-    case SpvOpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
-    }
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+inline void SpvHasResultAndType(SpvOp opcode, bool* hasResult,
+                                bool* hasResultType) {
+  *hasResult = *hasResultType = false;
+  switch (opcode) {
+    default: /* unknown opcode */
+      break;
+    case SpvOpNop:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpUndef:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSourceContinued:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSource:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSourceExtension:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpName:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpMemberName:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpString:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpLine:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpExtension:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpExtInstImport:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpExtInst:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpMemoryModel:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpEntryPoint:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpExecutionMode:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCapability:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeVoid:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeBool:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeInt:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeFloat:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeVector:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeMatrix:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeImage:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeSampler:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeSampledImage:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeArray:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeRuntimeArray:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeStruct:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeOpaque:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypePointer:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeFunction:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeEvent:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeDeviceEvent:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeReserveId:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeQueue:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypePipe:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeForwardPointer:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpConstantTrue:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConstantFalse:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConstant:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConstantComposite:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConstantSampler:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConstantNull:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSpecConstantTrue:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSpecConstantFalse:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSpecConstant:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSpecConstantComposite:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSpecConstantOp:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFunction:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFunctionParameter:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFunctionEnd:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpFunctionCall:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpVariable:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageTexelPointer:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLoad:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpStore:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCopyMemory:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCopyMemorySized:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpAccessChain:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpInBoundsAccessChain:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpPtrAccessChain:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArrayLength:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGenericPtrMemSemantics:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpInBoundsPtrAccessChain:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDecorate:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpMemberDecorate:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpDecorationGroup:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupDecorate:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupMemberDecorate:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpVectorExtractDynamic:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpVectorInsertDynamic:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpVectorShuffle:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCompositeConstruct:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCompositeExtract:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCompositeInsert:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCopyObject:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTranspose:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSampledImage:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleDrefImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleDrefExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleProjImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleProjExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleProjDrefImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleProjDrefExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageFetch:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageGather:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageDrefGather:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageRead:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageWrite:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpImage:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageQueryFormat:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageQueryOrder:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageQuerySizeLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageQuerySize:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageQueryLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageQueryLevels:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageQuerySamples:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertFToU:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertFToS:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertSToF:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertUToF:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUConvert:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSConvert:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFConvert:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpQuantizeToF16:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertPtrToU:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSatConvertSToU:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSatConvertUToS:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertUToPtr:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpPtrCastToGeneric:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGenericCastToPtr:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGenericCastToPtrExplicit:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitcast:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSNegate:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFNegate:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIAdd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFAdd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpISub:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFSub:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIMul:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFMul:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUDiv:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSDiv:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFDiv:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUMod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSRem:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSMod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFRem:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFMod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpVectorTimesScalar:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpMatrixTimesScalar:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpVectorTimesMatrix:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpMatrixTimesVector:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpMatrixTimesMatrix:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpOuterProduct:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIAddCarry:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpISubBorrow:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUMulExtended:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSMulExtended:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAny:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAll:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIsNan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIsInf:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIsFinite:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIsNormal:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSignBitSet:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLessOrGreater:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpOrdered:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUnordered:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLogicalEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLogicalNotEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLogicalOr:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLogicalAnd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLogicalNot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSelect:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpINotEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUGreaterThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSGreaterThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUGreaterThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSGreaterThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpULessThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSLessThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpULessThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSLessThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFOrdEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFUnordEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFOrdNotEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFUnordNotEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFOrdLessThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFUnordLessThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFOrdGreaterThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFUnordGreaterThan:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFOrdLessThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFUnordLessThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFOrdGreaterThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFUnordGreaterThanEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpShiftRightLogical:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpShiftRightArithmetic:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpShiftLeftLogical:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitwiseOr:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitwiseXor:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitwiseAnd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpNot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitFieldInsert:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitFieldSExtract:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitFieldUExtract:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitReverse:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBitCount:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDPdx:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDPdy:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFwidth:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDPdxFine:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDPdyFine:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFwidthFine:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDPdxCoarse:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDPdyCoarse:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFwidthCoarse:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpEmitVertex:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpEndPrimitive:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpEmitStreamVertex:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpEndStreamPrimitive:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpControlBarrier:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpMemoryBarrier:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpAtomicLoad:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicStore:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpAtomicExchange:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicCompareExchange:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicCompareExchangeWeak:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicIIncrement:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicIDecrement:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicIAdd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicISub:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicSMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicUMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicSMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicUMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicAnd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicOr:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicXor:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpPhi:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLoopMerge:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSelectionMerge:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpLabel:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpBranch:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpBranchConditional:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSwitch:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpKill:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpReturn:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpReturnValue:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpUnreachable:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpLifetimeStart:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpLifetimeStop:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupAsyncCopy:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupWaitEvents:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupAll:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupAny:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupBroadcast:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupIAdd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupFAdd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupFMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupUMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupSMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupFMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupUMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupSMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReadPipe:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpWritePipe:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReservedReadPipe:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReservedWritePipe:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReserveReadPipePackets:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReserveWritePipePackets:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCommitReadPipe:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCommitWritePipe:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpIsValidReserveId:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetNumPipePackets:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetMaxPipePackets:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupReserveReadPipePackets:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupReserveWritePipePackets:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupCommitReadPipe:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupCommitWritePipe:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpEnqueueMarker:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpEnqueueKernel:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetKernelNDrangeSubGroupCount:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetKernelNDrangeMaxSubGroupSize:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetKernelWorkGroupSize:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetKernelPreferredWorkGroupSizeMultiple:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRetainEvent:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpReleaseEvent:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCreateUserEvent:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIsValidEvent:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSetUserEventStatus:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCaptureEventProfilingInfo:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGetDefaultQueue:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBuildNDRange:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleDrefImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleDrefExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleProjImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleProjExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleProjDrefImplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseSampleProjDrefExplicitLod:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseFetch:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseGather:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseDrefGather:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSparseTexelsResident:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpNoLine:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpAtomicFlagTestAndSet:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicFlagClear:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpImageSparseRead:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSizeOf:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTypePipeStorage:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpConstantPipeStorage:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCreatePipeFromPipeStorage:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetKernelLocalSizeForSubgroupCount:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGetKernelMaxNumSubgroups:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTypeNamedBarrier:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpNamedBarrierInitialize:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpMemoryNamedBarrier:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpModuleProcessed:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpExecutionModeId:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpDecorateId:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupNonUniformElect:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformAll:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformAny:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformAllEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBroadcast:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBroadcastFirst:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBallot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformInverseBallot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBallotBitExtract:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBallotBitCount:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBallotFindLSB:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBallotFindMSB:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformShuffle:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformShuffleXor:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformShuffleUp:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformShuffleDown:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformIAdd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformFAdd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformIMul:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformFMul:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformSMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformUMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformFMin:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformSMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformUMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformFMax:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBitwiseAnd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBitwiseOr:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformBitwiseXor:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformLogicalAnd:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformLogicalOr:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformLogicalXor:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformQuadBroadcast:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformQuadSwap:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCopyLogical:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpPtrEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpPtrNotEqual:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpPtrDiff:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpColorAttachmentReadEXT:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDepthAttachmentReadEXT:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpStencilAttachmentReadEXT:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTerminateInvocation:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSubgroupBallotKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupFirstInvocationKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAllKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAnyKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAllEqualKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupNonUniformRotateKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupReadInvocationKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTraceRayKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpExecuteCallableKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpConvertUToAccelerationStructureKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIgnoreIntersectionKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTerminateRayKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSDot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUDot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSUDot:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSDotAccSat:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUDotAccSat:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSUDotAccSat:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTypeCooperativeMatrixKHR:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpCooperativeMatrixLoadKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCooperativeMatrixStoreKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCooperativeMatrixMulAddKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCooperativeMatrixLengthKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTypeRayQueryKHR:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpRayQueryInitializeKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpRayQueryTerminateKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpRayQueryGenerateIntersectionKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpRayQueryConfirmIntersectionKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpRayQueryProceedKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionTypeKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageSampleWeightedQCOM:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageBoxFilterQCOM:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageBlockMatchSSDQCOM:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpImageBlockMatchSADQCOM:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupIAddNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupFAddNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupFMinNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupUMinNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupSMinNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupFMaxNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupUMaxNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupSMaxNonUniformAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFragmentMaskFetchAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFragmentFetchAMD:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReadClockKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectRecordHitMotionNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectRecordHitWithIndexMotionNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectRecordMissMotionNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectGetWorldToObjectNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetObjectToWorldNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetObjectRayDirectionNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetObjectRayOriginNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectTraceRayMotionNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectGetShaderRecordBufferHandleNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetShaderBindingTableRecordIndexNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectRecordEmptyNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectTraceRayNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectRecordHitNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectRecordHitWithIndexNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectRecordMissNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectExecuteShaderNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectGetCurrentTimeNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetAttributesNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpHitObjectGetHitKindNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetPrimitiveIndexNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetGeometryIndexNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetInstanceIdNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetInstanceCustomIndexNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetWorldRayDirectionNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetWorldRayOriginNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetRayTMaxNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectGetRayTMinNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectIsEmptyNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectIsHitNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpHitObjectIsMissNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReorderThreadWithHitObjectNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpReorderThreadWithHintNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeHitObjectNV:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpImageSampleFootprintNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpEmitMeshTasksEXT:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSetMeshOutputsEXT:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupNonUniformPartitionNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpWritePackedPrimitiveIndices4x8NV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpReportIntersectionNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIgnoreIntersectionNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTerminateRayNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTraceNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTraceMotionNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTraceRayMotionNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTypeAccelerationStructureNV:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpExecuteCallableNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeCooperativeMatrixNV:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpCooperativeMatrixLoadNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCooperativeMatrixStoreNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpCooperativeMatrixMulAddNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCooperativeMatrixLengthNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpBeginInvocationInterlockEXT:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpEndInvocationInterlockEXT:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpDemoteToHelperInvocation:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpIsHelperInvocationEXT:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertUToImageNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertUToSamplerNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertImageToUNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertSamplerToUNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertUToSampledImageNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertSampledImageToUNV:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSamplerImageAddressingModeNV:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSubgroupShuffleINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupShuffleDownINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupShuffleUpINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupShuffleXorINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupBlockReadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupBlockWriteINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSubgroupImageBlockReadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupImageBlockWriteINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSubgroupImageMediaBlockReadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupImageMediaBlockWriteINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpUCountLeadingZerosINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUCountTrailingZerosINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAbsISubINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAbsUSubINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIAddSatINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUAddSatINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIAverageINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUAverageINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIAverageRoundedINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUAverageRoundedINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpISubSatINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUSubSatINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpIMul32x16INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpUMul32x16INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConstantFunctionPointerINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFunctionPointerCallINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAsmTargetINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAsmINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAsmCallINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicFMinEXT:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicFMaxEXT:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAssumeTrueKHR:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpExpectKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpDecorateString:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpMemberDecorateString:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpVmeImageINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTypeVmeImageINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcImePayloadINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcRefPayloadINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcSicPayloadINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcMcePayloadINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcMceResultINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcImeResultINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcImeSingleReferenceStreaminINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcImeDualReferenceStreaminINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcRefResultINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeAvcSicResultINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceConvertToImePayloadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceConvertToImeResultINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceConvertToRefResultINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceConvertToSicResultINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetMotionVectorsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetInterDistortionsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetInterDirectionsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeInitializeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeSetSingleReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeSetDualReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeRefWindowSizeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeSetWeightedSadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeConvertToMceResultINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetBorderReachedINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcFmeInitializeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcBmeInitializeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcRefConvertToMceResultINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicInitializeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicConfigureSkcINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicEvaluateIpeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicConvertToMceResultINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSubgroupAvcSicGetInterRawSadsINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpVariableLengthArrayINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpSaveMemoryINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRestoreMemoryINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpArbitraryFloatSinCosPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatCastINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatCastFromIntINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatCastToIntINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatAddINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatSubINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatMulINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatDivINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatGTINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatGEINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatLTINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatLEINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatEQINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatRecipINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatRSqrtINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatCbrtINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatHypotINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatSqrtINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatLogINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatLog2INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatLog10INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatLog1pINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatExpINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatExp2INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatExp10INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatExpm1INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatSinINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatCosINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatSinCosINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatSinPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatCosPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatASinINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatASinPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatACosINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatACosPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatATanINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatATanPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatATan2INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatPowINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatPowRINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpArbitraryFloatPowNINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpLoopControlINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpAliasDomainDeclINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpAliasScopeDeclINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpAliasScopeListDeclINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpFixedSqrtINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedRecipINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedRsqrtINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedSinINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedCosINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedSinCosINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedSinPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedCosPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedSinCosPiINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedLogINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFixedExpINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpPtrCastToCrossWorkgroupINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpCrossWorkgroupCastToPtrINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpReadPipeBlockingINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpWritePipeBlockingINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpFPGARegINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetRayTMinKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetRayFlagsKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionTKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionInstanceIdKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionGeometryIndexKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionBarycentricsKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionFrontFaceKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionObjectRayOriginKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetWorldRayDirectionKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetWorldRayOriginKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionObjectToWorldKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpRayQueryGetIntersectionWorldToObjectKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpAtomicFAddEXT:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpTypeBufferSurfaceINTEL:
+      *hasResult = true;
+      *hasResultType = false;
+      break;
+    case SpvOpTypeStructContinuedINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpConstantCompositeContinuedINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpSpecConstantCompositeContinuedINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpConvertFToBF16INTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpConvertBF16ToFINTEL:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpControlBarrierArriveINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpControlBarrierWaitINTEL:
+      *hasResult = false;
+      *hasResultType = false;
+      break;
+    case SpvOpGroupIMulKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupFMulKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupBitwiseAndKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupBitwiseOrKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupBitwiseXorKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupLogicalAndKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupLogicalOrKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+    case SpvOpGroupLogicalXorKHR:
+      *hasResult = true;
+      *hasResultType = true;
+      break;
+  }
 }
 #endif /* SPV_ENABLE_UTILITY_CODE */
 
 #endif
-
diff --git a/WickedEngine/Utility/spirv_reflect.c b/WickedEngine/Utility/spirv_reflect.c
index 82fc6fa0a..efb1149e1 100644
--- a/WickedEngine/Utility/spirv_reflect.c
+++ b/WickedEngine/Utility/spirv_reflect.c
@@ -1,5 +1,5 @@
 /*
- Copyright 2017-2018 Google Inc.
+ Copyright 2017-2022 Google Inc.
 
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
@@ -15,36 +15,31 @@
 */
 
 #include "spirv_reflect.h"
+
 #include <assert.h>
 #include <stdbool.h>
 #include <string.h>
 
 #if defined(WIN32)
-  #define _CRTDBG_MAP_ALLOC
-  #include <stdlib.h>
-  #include <crtdbg.h>
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#include <stdlib.h>
 #else
-  #include <stdlib.h>
+#include <stdlib.h>
+#endif
+
+#if defined(__clang__) || (defined(__GNUC__) && __GNUC__ >= 7) || defined(__APPLE_CC__)
+#define FALLTHROUGH __attribute__((fallthrough))
+#else
+#define FALLTHROUGH
 #endif
 
 #if defined(SPIRV_REFLECT_ENABLE_ASSERTS)
-  #define SPV_REFLECT_ASSERT(COND) \
-    assert(COND);
+#define SPV_REFLECT_ASSERT(COND) assert(COND);
 #else
 #define SPV_REFLECT_ASSERT(COND)
 #endif
 
-// Temporary enums until these make it into SPIR-V/Vulkan
-// clang-format off
-enum {
-  SpvReflectOpDecorateId                      = 332,
-  SpvReflectOpDecorateStringGOOGLE            = 5632,
-  SpvReflectOpMemberDecorateStringGOOGLE      = 5633,
-  SpvReflectDecorationHlslCounterBufferGOOGLE = 5634,
-  SpvReflectDecorationHlslSemanticGOOGLE      = 5635
-};
-// clang-format on
-
 // clang-format off
 enum {
   SPIRV_STARTING_WORD_INDEX       = 5,
@@ -54,199 +49,222 @@ enum {
   SPIRV_DATA_ALIGNMENT            = 4 * SPIRV_WORD_SIZE, // 16
   SPIRV_ACCESS_CHAIN_INDEX_OFFSET = 4,
 };
-// clang-format on
 
-// clang-format off
 enum {
   INVALID_VALUE  = 0xFFFFFFFF,
 };
-// clang-format on
 
-// clang-format off
 enum {
-  MAX_NODE_NAME_LENGTH      = 1024,
+  MAX_NODE_NAME_LENGTH        = 1024,
+  // Number of unique PhysicalStorageBuffer structs tracked to detect recursion
+  MAX_RECURSIVE_PHYSICAL_POINTER_CHECK = 128,
 };
-// clang-format on
 
-// clang-format off
 enum {
   IMAGE_SAMPLED = 1,
-  IMAGE_STORAGE = 2
+  IMAGE_STORAGE = 2,
 };
-// clang-format on
 
-// clang-format off
-typedef struct ArrayTraits {
-  uint32_t              element_type_id;
-  uint32_t              length_id;
-} ArrayTraits;
-// clang-format on
+typedef struct SpvReflectPrvArrayTraits {
+  uint32_t                        element_type_id;
+  uint32_t                        length_id;
+} SpvReflectPrvArrayTraits;
 
-// clang-format off
-typedef struct ImageTraits {
-  uint32_t              sampled_type_id;
-  SpvDim                dim;
-  uint32_t              depth;
-  uint32_t              arrayed;
-  uint32_t              ms;
-  uint32_t              sampled;
-  SpvImageFormat        image_format;
-} ImageTraits;
-// clang-format on
+typedef struct SpvReflectPrvImageTraits {
+  uint32_t                        sampled_type_id;
+  SpvDim                          dim;
+  uint32_t                        depth;
+  uint32_t                        arrayed;
+  uint32_t                        ms;
+  uint32_t                        sampled;
+  SpvImageFormat                  image_format;
+} SpvReflectPrvImageTraits;
 
-// clang-format off
-typedef struct NumberDecoration {
-  uint32_t              word_offset;
-  uint32_t              value;
-} NumberDecoration;
-// clang-format on
+typedef struct SpvReflectPrvNumberDecoration {
+  uint32_t                        word_offset;
+  uint32_t                        value;
+} SpvReflectPrvNumberDecoration;
 
-// clang-format off
-typedef struct StringDecoration {
-  uint32_t              word_offset;
-  const char*           value;
-} StringDecoration;
-// clang-format on
+typedef struct SpvReflectPrvStringDecoration {
+  uint32_t                        word_offset;
+  const char*                     value;
+} SpvReflectPrvStringDecoration;
 
-// clang-format off
-typedef struct Decorations {
-  bool                  is_block;
-  bool                  is_buffer_block;
-  bool                  is_row_major;
-  bool                  is_column_major;
-  bool                  is_built_in;
-  bool                  is_noperspective;
-  bool                  is_flat;
-  bool                  is_non_writable;
-  NumberDecoration      set;
-  NumberDecoration      binding;
-  NumberDecoration      input_attachment_index;
-  NumberDecoration      location;
-  NumberDecoration      offset;
-  NumberDecoration      uav_counter_buffer;
-  StringDecoration      semantic;
-  uint32_t              array_stride;
-  uint32_t              matrix_stride;
-  SpvBuiltIn            built_in;
-} Decorations;
-// clang-format on
+typedef struct SpvReflectPrvDecorations {
+  bool                            is_relaxed_precision;
+  bool                            is_block;
+  bool                            is_buffer_block;
+  bool                            is_row_major;
+  bool                            is_column_major;
+  bool                            is_built_in;
+  bool                            is_noperspective;
+  bool                            is_flat;
+  bool                            is_non_writable;
+  bool                            is_non_readable;
+  bool                            is_patch;
+  bool                            is_per_vertex;
+  bool                            is_per_task;
+  bool                            is_weight_texture;
+  bool                            is_block_match_texture;
+  SpvReflectUserType              user_type;
+  SpvReflectPrvNumberDecoration   set;
+  SpvReflectPrvNumberDecoration   binding;
+  SpvReflectPrvNumberDecoration   input_attachment_index;
+  SpvReflectPrvNumberDecoration   location;
+  SpvReflectPrvNumberDecoration   component;
+  SpvReflectPrvNumberDecoration   offset;
+  SpvReflectPrvNumberDecoration   uav_counter_buffer;
+  SpvReflectPrvStringDecoration   semantic;
+  uint32_t                        array_stride;
+  uint32_t                        matrix_stride;
+  uint32_t                        spec_id;
+  SpvBuiltIn                      built_in;
+} SpvReflectPrvDecorations;
 
-// clang-format off
-typedef struct Node {
-  uint32_t              result_id;
-  SpvOp                 op;
-  uint32_t              result_type_id;
-  uint32_t              type_id;
-  SpvStorageClass       storage_class;
-  uint32_t              word_offset;
-  uint32_t              word_count;
-  bool                  is_type;
+typedef struct SpvReflectPrvNode {
+  uint32_t                        result_id;
+  SpvOp                           op;
+  uint32_t                        result_type_id;
+  uint32_t                        type_id;
+  SpvCapability                   capability;
+  SpvStorageClass                 storage_class;
+  uint32_t                        word_offset;
+  uint32_t                        word_count;
+  bool                            is_type;
 
-  ArrayTraits           array_traits;
-  ImageTraits           image_traits;
-  uint32_t              image_type_id;
+  SpvReflectPrvArrayTraits        array_traits;
+  SpvReflectPrvImageTraits        image_traits;
+  uint32_t                        image_type_id;
 
-  const char*           name;
-  Decorations           decorations;
-  uint32_t              member_count;
-  const char**          member_names;
-  Decorations*          member_decorations;
-} Node;
-// clang-format on
+  const char*                     name;
+  SpvReflectPrvDecorations        decorations;
+  uint32_t                        member_count;
+  const char**                    member_names;
+  SpvReflectPrvDecorations*       member_decorations;
+} SpvReflectPrvNode;
 
-// clang-format off
-typedef struct String {
-  uint32_t              result_id;
-  const char*           string;
-} String;
-// clang-format on
+typedef struct SpvReflectPrvString {
+  uint32_t                        result_id;
+  const char*                     string;
+} SpvReflectPrvString;
 
-// clang-format off
-typedef struct Function {
-  uint32_t              id;
-  uint32_t              callee_count;
-  uint32_t*             callees;
-  struct Function**     callee_ptrs;
-  uint32_t              accessed_ptr_count;
-  uint32_t*             accessed_ptrs;
-} Function;
-// clang-format on
+// There are a limit set of instructions that can touch an OpVariable,
+// these are represented here with how it was accessed
+// Examples:
+//    OpImageRead  -> OpLoad -> OpVariable
+//    OpImageWrite -> OpLoad -> OpVariable
+//    OpStore      -> OpAccessChain -> OpAccessChain -> OpVariable
+//    OpAtomicIAdd -> OpAccessChain -> OpVariable
+//    OpAtomicLoad -> OpImageTexelPointer -> OpVariable
+typedef struct SpvReflectPrvAccessedVariable {
+  SpvReflectPrvNode*     p_node;
+  uint32_t               result_id;
+  uint32_t               variable_ptr;
+  uint32_t               function_id;
+  uint32_t               function_parameter_index;
+} SpvReflectPrvAccessedVariable;
 
-// clang-format off
-typedef struct AccessChain {
-  uint32_t              result_id;
-  uint32_t              result_type_id;
+typedef struct SpvReflectPrvFunction {
+  uint32_t                        id;
+  uint32_t                        parameter_count;
+  uint32_t*                       parameters;
+  uint32_t                        callee_count;
+  uint32_t*                       callees;
+  struct SpvReflectPrvFunction**  callee_ptrs;
+  uint32_t                        accessed_variable_count;
+  SpvReflectPrvAccessedVariable*  accessed_variables;
+} SpvReflectPrvFunction;
+
+typedef struct SpvReflectPrvAccessChain {
+  uint32_t                        result_id;
+  uint32_t                        result_type_id;
   //
   // Pointing to the base of a composite object.
   // Generally the id of descriptor block variable
-  uint32_t              base_id;
-  // 
+  uint32_t                        base_id;
+  //
   // From spec:
-  //   The first index in Indexes will select the 
-  //   top-level member/element/component/element 
+  //   The first index in Indexes will select the
+  //   top-level member/element/component/element
   //   of the base composite
-  uint32_t              index_count;
-  uint32_t*             indexes;
-} AccessChain;
+  uint32_t                        index_count;
+  uint32_t*                       indexes;
+  //
+  // Block variable ac is pointing to (for block references)
+  SpvReflectBlockVariable*        block_var;
+} SpvReflectPrvAccessChain;
+
+// To prevent infinite recursion, we never walk down a
+// PhysicalStorageBuffer struct twice, but incase a 2nd variable
+// needs to use that struct, save a copy
+typedef struct SpvReflectPrvPhysicalPointerStruct {
+    uint32_t struct_id;
+    // first variable to see the PhysicalStorageBuffer struct
+    SpvReflectBlockVariable* p_var;
+} SpvReflectPrvPhysicalPointerStruct;
+
+typedef struct SpvReflectPrvParser {
+  size_t                          spirv_word_count;
+  uint32_t*                       spirv_code;
+  uint32_t                        string_count;
+  SpvReflectPrvString*            strings;
+  SpvSourceLanguage               source_language;
+  uint32_t                        source_language_version;
+  uint32_t                        source_file_id;
+  const char*                     source_embedded;
+  size_t                          node_count;
+  SpvReflectPrvNode*              nodes;
+  uint32_t                        entry_point_count;
+  uint32_t                        capability_count;
+  uint32_t                        function_count;
+  SpvReflectPrvFunction*          functions;
+  uint32_t                        access_chain_count;
+  SpvReflectPrvAccessChain*       access_chains;
+
+  uint32_t                        type_count;
+  uint32_t                        descriptor_count;
+  uint32_t                        push_constant_count;
+
+  SpvReflectTypeDescription*      physical_pointer_check[MAX_RECURSIVE_PHYSICAL_POINTER_CHECK];
+  uint32_t                        physical_pointer_count;
+
+  SpvReflectPrvPhysicalPointerStruct* physical_pointer_structs;
+  uint32_t                            physical_pointer_struct_count;
+} SpvReflectPrvParser;
 // clang-format on
 
-// clang-format off
-typedef struct Parser {
-  size_t                spirv_word_count;
-  uint32_t*             spirv_code;
-  uint32_t              string_count;
-  String*               strings;
-  SpvSourceLanguage     source_language;
-  uint32_t              source_language_version;
-  uint32_t              source_file_id;
-  const char*           source_embedded;
-  size_t                node_count;
-  Node*                 nodes;
-  uint32_t              entry_point_count;
-  uint32_t              function_count;
-  Function*             functions;
-  uint32_t              access_chain_count;
-  AccessChain*          access_chains;
+static uint32_t Max(uint32_t a, uint32_t b) { return a > b ? a : b; }
+static uint32_t Min(uint32_t a, uint32_t b) { return a < b ? a : b; }
 
-  uint32_t              type_count;
-  uint32_t              descriptor_count;
-  uint32_t              push_constant_count;
-} Parser;
-// clang-format on
-
-static uint32_t Max(uint32_t a, uint32_t b)
-{
-  return a > b ? a : b;
-}
-
-static uint32_t RoundUp(uint32_t value, uint32_t multiple)
-{
+static uint32_t RoundUp(uint32_t value, uint32_t multiple) {
   assert(multiple && ((multiple & (multiple - 1)) == 0));
   return (value + multiple - 1) & ~(multiple - 1);
 }
 
-#define IsNull(ptr) \
-  (ptr == NULL)
+#define IsNull(ptr) (ptr == NULL)
 
-#define IsNotNull(ptr) \
-  (ptr != NULL)
+#define IsNotNull(ptr) (ptr != NULL)
 
-#define SafeFree(ptr)    \
-  {                      \
-     if (ptr != NULL) {  \
-       free((void*)ptr); \
-       ptr = NULL;       \
-     }                   \
+#define SafeFree(ptr) \
+  {                   \
+    free((void*)ptr); \
+    ptr = NULL;       \
   }
 
-static int SortCompareUint32(const void* a, const void* b)
-{
+static int SortCompareUint32(const void* a, const void* b) {
   const uint32_t* p_a = (const uint32_t*)a;
   const uint32_t* p_b = (const uint32_t*)b;
 
   return (int)*p_a - (int)*p_b;
 }
 
+static int SortCompareAccessedVariable(const void* a, const void* b) {
+  const SpvReflectPrvAccessedVariable* p_a = (const SpvReflectPrvAccessedVariable*)a;
+  const SpvReflectPrvAccessedVariable* p_b = (const SpvReflectPrvAccessedVariable*)b;
+
+  return (int)p_a->variable_ptr - (int)p_b->variable_ptr;
+}
+
 //
 // De-duplicates a sorted array and returns the new size.
 //
@@ -254,8 +272,7 @@ static int SortCompareUint32(const void* a, const void* b)
 // arranged into "runs" so that all the entries with one
 // value are adjacent.
 //
-static size_t DedupSortedUint32(uint32_t* arr, size_t size)
-{
+static size_t DedupSortedUint32(uint32_t* arr, size_t size) {
   if (size == 0) {
     return 0;
   }
@@ -266,11 +283,10 @@ static size_t DedupSortedUint32(uint32_t* arr, size_t size)
       arr[dedup_idx] = arr[i];
     }
   }
-  return dedup_idx+1;
+  return dedup_idx + 1;
 }
 
-static bool SearchSortedUint32(const uint32_t* arr, size_t size, uint32_t target)
-{
+static bool SearchSortedUint32(const uint32_t* arr, size_t size, uint32_t target) {
   size_t lo = 0;
   size_t hi = size;
   while (lo < hi) {
@@ -278,7 +294,7 @@ static bool SearchSortedUint32(const uint32_t* arr, size_t size, uint32_t target
     if (arr[mid] == target) {
       return true;
     } else if (arr[mid] < target) {
-      lo = mid+1;
+      lo = mid + 1;
     } else {
       hi = mid;
     }
@@ -286,60 +302,56 @@ static bool SearchSortedUint32(const uint32_t* arr, size_t size, uint32_t target
   return false;
 }
 
-static SpvReflectResult IntersectSortedUint32(
-  const uint32_t* p_arr0, 
-  size_t          arr0_size,
-  const uint32_t* p_arr1, 
-  size_t          arr1_size,
-  uint32_t**      pp_res,
-  size_t*         res_size
-)
-{
+static SpvReflectResult IntersectSortedAccessedVariable(const SpvReflectPrvAccessedVariable* p_arr0, size_t arr0_size,
+                                                        const uint32_t* p_arr1, size_t arr1_size, uint32_t** pp_res,
+                                                        size_t* res_size) {
+  *pp_res = NULL;
   *res_size = 0;
-  const uint32_t* arr0_end = p_arr0 + arr0_size;
-  const uint32_t* arr1_end = p_arr1 + arr1_size;
+  if (IsNull(p_arr0) || IsNull(p_arr1)) {
+    return SPV_REFLECT_RESULT_SUCCESS;
+  }
 
-  const uint32_t* idx0 = p_arr0;
-  const uint32_t* idx1 = p_arr1;
-  while (idx0 != arr0_end && idx1 != arr1_end) {
-    if (*idx0 < *idx1) {
-      ++idx0;
-    } else if (*idx0 > *idx1) {
-      ++idx1;
+  const SpvReflectPrvAccessedVariable* p_arr0_end = p_arr0 + arr0_size;
+  const uint32_t* p_arr1_end = p_arr1 + arr1_size;
+
+  const SpvReflectPrvAccessedVariable* p_idx0 = p_arr0;
+  const uint32_t* p_idx1 = p_arr1;
+  while (p_idx0 != p_arr0_end && p_idx1 != p_arr1_end) {
+    if (p_idx0->variable_ptr < *p_idx1) {
+      ++p_idx0;
+    } else if (p_idx0->variable_ptr > *p_idx1) {
+      ++p_idx1;
     } else {
       ++*res_size;
-      ++idx0;
-      ++idx1;
+      ++p_idx0;
+      ++p_idx1;
     }
   }
 
-  *pp_res = NULL;
   if (*res_size > 0) {
     *pp_res = (uint32_t*)calloc(*res_size, sizeof(**pp_res));
     if (IsNull(*pp_res)) {
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
-    uint32_t* idxr = *pp_res;
-    idx0 = p_arr0;
-    idx1 = p_arr1;
-    while (idx0 != arr0_end && idx1 != arr1_end) {
-      if (*idx0 < *idx1) {
-        ++idx0;
-      } else if (*idx0 > *idx1) {
-        ++idx1;
+    uint32_t* p_idxr = *pp_res;
+    p_idx0 = p_arr0;
+    p_idx1 = p_arr1;
+    while (p_idx0 != p_arr0_end && p_idx1 != p_arr1_end) {
+      if (p_idx0->variable_ptr < *p_idx1) {
+        ++p_idx0;
+      } else if (p_idx0->variable_ptr > *p_idx1) {
+        ++p_idx1;
       } else {
-        *(idxr++) = *idx0;
-        ++idx0;
-        ++idx1;
+        *(p_idxr++) = p_idx0->variable_ptr;
+        ++p_idx0;
+        ++p_idx1;
       }
     }
   }
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-
-static bool InRange(const Parser* p_parser, uint32_t index)
-{
+static bool InRange(const SpvReflectPrvParser* p_parser, uint32_t index) {
   bool in_range = false;
   if (IsNotNull(p_parser)) {
     in_range = (index < p_parser->spirv_word_count);
@@ -347,8 +359,7 @@ static bool InRange(const Parser* p_parser, uint32_t index)
   return in_range;
 }
 
-static SpvReflectResult ReadU32(Parser* p_parser, uint32_t word_offset, uint32_t* p_value)
-{
+static SpvReflectResult ReadU32(SpvReflectPrvParser* p_parser, uint32_t word_offset, uint32_t* p_value) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
   assert(InRange(p_parser, word_offset));
@@ -360,25 +371,25 @@ static SpvReflectResult ReadU32(Parser* p_parser, uint32_t word_offset, uint32_t
   return result;
 }
 
-#define CHECKED_READU32(parser, word_offset, value)                                      \
-  {                                                                                      \
-    SpvReflectResult checked_readu32_result = ReadU32(parser,                            \
-                                                      word_offset, (uint32_t*)&(value)); \
-    if (checked_readu32_result != SPV_REFLECT_RESULT_SUCCESS) {                          \
-      return checked_readu32_result;                                                     \
-    }                                                                                    \
+#define UNCHECKED_READU32(parser, word_offset, value) \
+  { (void)ReadU32(parser, word_offset, (uint32_t*)&(value)); }
+
+#define CHECKED_READU32(parser, word_offset, value)                                              \
+  {                                                                                              \
+    SpvReflectResult checked_readu32_result = ReadU32(parser, word_offset, (uint32_t*)&(value)); \
+    if (checked_readu32_result != SPV_REFLECT_RESULT_SUCCESS) {                                  \
+      return checked_readu32_result;                                                             \
+    }                                                                                            \
   }
 
-#define CHECKED_READU32_CAST(parser, word_offset, cast_to_type, value)         \
-  {                                                                            \
-    uint32_t checked_readu32_cast_u32 = UINT32_MAX;                            \
-    SpvReflectResult checked_readu32_cast_result = ReadU32(parser,             \
-                                      word_offset,                             \
-                                      (uint32_t*)&(checked_readu32_cast_u32)); \
-    if (checked_readu32_cast_result != SPV_REFLECT_RESULT_SUCCESS) {           \
-      return checked_readu32_cast_result;                                      \
-    }                                                                          \
-    value = (cast_to_type)checked_readu32_cast_u32;                            \
+#define CHECKED_READU32_CAST(parser, word_offset, cast_to_type, value)                                                   \
+  {                                                                                                                      \
+    uint32_t checked_readu32_cast_u32 = UINT32_MAX;                                                                      \
+    SpvReflectResult checked_readu32_cast_result = ReadU32(parser, word_offset, (uint32_t*)&(checked_readu32_cast_u32)); \
+    if (checked_readu32_cast_result != SPV_REFLECT_RESULT_SUCCESS) {                                                     \
+      return checked_readu32_cast_result;                                                                                \
+    }                                                                                                                    \
+    value = (cast_to_type)checked_readu32_cast_u32;                                                                      \
   }
 
 #define IF_READU32(result, parser, word_offset, value)          \
@@ -395,15 +406,8 @@ static SpvReflectResult ReadU32(Parser* p_parser, uint32_t word_offset, uint32_t
     }                                                                     \
   }
 
-static SpvReflectResult ReadStr(
-  Parser*   p_parser, 
-  uint32_t  word_offset, 
-  uint32_t  word_index, 
-  uint32_t  word_count,
-  uint32_t* p_buf_size, 
-  char*     p_buf
-)
-{
+static SpvReflectResult ReadStr(SpvReflectPrvParser* p_parser, uint32_t word_offset, uint32_t word_index, uint32_t word_count,
+                                uint32_t* p_buf_size, char* p_buf) {
   uint32_t limit = (word_offset + word_count);
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
@@ -430,8 +434,7 @@ static SpvReflectResult ReadStr(
           memcpy(p_buf, c_str, length_with_terminator);
           result = SPV_REFLECT_RESULT_SUCCESS;
         }
-      }
-      else {
+      } else {
         if (IsNotNull(p_buf_size)) {
           *p_buf_size = length_with_terminator;
           result = SPV_REFLECT_RESULT_SUCCESS;
@@ -442,9 +445,11 @@ static SpvReflectResult ReadStr(
   return result;
 }
 
-static SpvReflectDecorationFlags ApplyDecorations(const Decorations* p_decoration_fields)
-{
+static SpvReflectDecorationFlags ApplyDecorations(const SpvReflectPrvDecorations* p_decoration_fields) {
   SpvReflectDecorationFlags decorations = SPV_REFLECT_DECORATION_NONE;
+  if (p_decoration_fields->is_relaxed_precision) {
+    decorations |= SPV_REFLECT_DECORATION_RELAXED_PRECISION;
+  }
   if (p_decoration_fields->is_block) {
     decorations |= SPV_REFLECT_DECORATION_BLOCK;
   }
@@ -469,24 +474,44 @@ static SpvReflectDecorationFlags ApplyDecorations(const Decorations* p_decoratio
   if (p_decoration_fields->is_non_writable) {
     decorations |= SPV_REFLECT_DECORATION_NON_WRITABLE;
   }
+  if (p_decoration_fields->is_non_readable) {
+    decorations |= SPV_REFLECT_DECORATION_NON_READABLE;
+  }
+  if (p_decoration_fields->is_patch) {
+    decorations |= SPV_REFLECT_DECORATION_PATCH;
+  }
+  if (p_decoration_fields->is_per_vertex) {
+    decorations |= SPV_REFLECT_DECORATION_PER_VERTEX;
+  }
+  if (p_decoration_fields->is_per_task) {
+    decorations |= SPV_REFLECT_DECORATION_PER_TASK;
+  }
+  if (p_decoration_fields->is_weight_texture) {
+    decorations |= SPV_REFLECT_DECORATION_WEIGHT_TEXTURE;
+  }
+  if (p_decoration_fields->is_block_match_texture) {
+    decorations |= SPV_REFLECT_DECORATION_BLOCK_MATCH_TEXTURE;
+  }
   return decorations;
 }
 
-static void ApplyNumericTraits(const SpvReflectTypeDescription* p_type, SpvReflectNumericTraits* p_numeric_traits)
-{
+static void ApplyNumericTraits(const SpvReflectTypeDescription* p_type, SpvReflectNumericTraits* p_numeric_traits) {
   memcpy(p_numeric_traits, &p_type->traits.numeric, sizeof(p_type->traits.numeric));
 }
 
-static void ApplyArrayTraits(const SpvReflectTypeDescription* p_type, SpvReflectArrayTraits* p_array_traits)
-{
+static void ApplyArrayTraits(const SpvReflectTypeDescription* p_type, SpvReflectArrayTraits* p_array_traits) {
   memcpy(p_array_traits, &p_type->traits.array, sizeof(p_type->traits.array));
 }
 
-static Node* FindNode(Parser* p_parser, uint32_t result_id)
-{
-  Node* p_node = NULL;
+static bool IsSpecConstant(const SpvReflectPrvNode* p_node) {
+  return (p_node->op == SpvOpSpecConstant || p_node->op == SpvOpSpecConstantOp || p_node->op == SpvOpSpecConstantTrue ||
+          p_node->op == SpvOpSpecConstantFalse);
+}
+
+static SpvReflectPrvNode* FindNode(SpvReflectPrvParser* p_parser, uint32_t result_id) {
+  SpvReflectPrvNode* p_node = NULL;
   for (size_t i = 0; i < p_parser->node_count; ++i) {
-    Node* p_elem = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_elem = &(p_parser->nodes[i]);
     if (p_elem->result_id == result_id) {
       p_node = p_elem;
       break;
@@ -495,8 +520,7 @@ static Node* FindNode(Parser* p_parser, uint32_t result_id)
   return p_node;
 }
 
-static SpvReflectTypeDescription* FindType(SpvReflectShaderModule* p_module, uint32_t type_id)
-{
+static SpvReflectTypeDescription* FindType(SpvReflectShaderModule* p_module, uint32_t type_id) {
   SpvReflectTypeDescription* p_type = NULL;
   for (size_t i = 0; i < p_module->_internal->type_description_count; ++i) {
     SpvReflectTypeDescription* p_elem = &(p_module->_internal->type_descriptions[i]);
@@ -508,8 +532,84 @@ static SpvReflectTypeDescription* FindType(SpvReflectShaderModule* p_module, uin
   return p_type;
 }
 
-static SpvReflectResult CreateParser(size_t size, void* p_code, Parser* p_parser)
-{
+static SpvReflectPrvAccessChain* FindAccessChain(SpvReflectPrvParser* p_parser, uint32_t id) {
+  const uint32_t ac_count = p_parser->access_chain_count;
+  for (uint32_t i = 0; i < ac_count; i++) {
+    if (p_parser->access_chains[i].result_id == id) {
+      return &p_parser->access_chains[i];
+    }
+  }
+  return 0;
+}
+
+// Access Chains mostly have their Base ID pointed directly to a OpVariable, but sometimes
+// it will be through a load and this funciton handles the edge cases how to find that
+static uint32_t FindAccessChainBaseVariable(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessChain* p_access_chain) {
+  uint32_t base_id = p_access_chain->base_id;
+  SpvReflectPrvNode* base_node = FindNode(p_parser, base_id);
+  // TODO - This is just a band-aid to fix crashes.
+  // Need to understand why here and hopefully remove
+  // https://github.com/KhronosGroup/SPIRV-Reflect/pull/206
+  if (IsNull(base_node)) {
+    return 0;
+  }
+  while (base_node->op != SpvOpVariable) {
+    switch (base_node->op) {
+      case SpvOpLoad: {
+        UNCHECKED_READU32(p_parser, base_node->word_offset + 3, base_id);
+      } break;
+      case SpvOpFunctionParameter: {
+        UNCHECKED_READU32(p_parser, base_node->word_offset + 2, base_id);
+      } break;
+      case SpvOpBitcast:
+        // This can be caused by something like GL_EXT_buffer_reference_uvec2 trying to load a pointer.
+        // We currently call from a push constant, so no way to have a reference loop back into the PC block
+        return 0;
+      default: {
+        assert(false);
+      } break;
+    }
+
+    SpvReflectPrvAccessChain* base_ac = FindAccessChain(p_parser, base_id);
+    if (base_ac == 0) {
+      return 0;
+    }
+    base_id = base_ac->base_id;
+    base_node = FindNode(p_parser, base_id);
+    if (IsNull(base_node)) {
+      return 0;
+    }
+  }
+  return base_id;
+}
+
+static SpvReflectBlockVariable* GetRefBlkVar(SpvReflectPrvParser* p_parser, SpvReflectPrvAccessChain* p_access_chain) {
+  uint32_t base_id = p_access_chain->base_id;
+  SpvReflectPrvNode* base_node = FindNode(p_parser, base_id);
+  assert(base_node->op == SpvOpLoad);
+  UNCHECKED_READU32(p_parser, base_node->word_offset + 3, base_id);
+  SpvReflectPrvAccessChain* base_ac = FindAccessChain(p_parser, base_id);
+  assert(base_ac != 0);
+  SpvReflectBlockVariable* base_var = base_ac->block_var;
+  assert(base_var != 0);
+  return base_var;
+}
+
+bool IsPointerToPointer(SpvReflectPrvParser* p_parser, uint32_t type_id) {
+  SpvReflectPrvNode* ptr_node = FindNode(p_parser, type_id);
+  if (IsNull(ptr_node) || (ptr_node->op != SpvOpTypePointer)) {
+    return false;
+  }
+  uint32_t pte_id = 0;
+  UNCHECKED_READU32(p_parser, ptr_node->word_offset + 3, pte_id);
+  SpvReflectPrvNode* pte_node = FindNode(p_parser, pte_id);
+  if (IsNull(pte_node)) {
+    return false;
+  }
+  return pte_node->op == SpvOpTypePointer;
+}
+
+static SpvReflectResult CreateParser(size_t size, void* p_code, SpvReflectPrvParser* p_parser) {
   if (p_code == NULL) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -531,12 +631,11 @@ static SpvReflectResult CreateParser(size_t size, void* p_code, Parser* p_parser
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static void DestroyParser(Parser* p_parser)
-{
+static void DestroyParser(SpvReflectPrvParser* p_parser) {
   if (!IsNull(p_parser->nodes)) {
     // Free nodes
     for (size_t i = 0; i < p_parser->node_count; ++i) {
-      Node* p_node = &(p_parser->nodes[i]);
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
       if (IsNotNull(p_node->member_names)) {
         SafeFree(p_node->member_names);
       }
@@ -547,9 +646,10 @@ static void DestroyParser(Parser* p_parser)
 
     // Free functions
     for (size_t i = 0; i < p_parser->function_count; ++i) {
+      SafeFree(p_parser->functions[i].parameters);
       SafeFree(p_parser->functions[i].callees);
       SafeFree(p_parser->functions[i].callee_ptrs);
-      SafeFree(p_parser->functions[i].accessed_ptrs);
+      SafeFree(p_parser->functions[i].accessed_variables);
     }
 
     // Free access chains
@@ -562,12 +662,15 @@ static void DestroyParser(Parser* p_parser)
     SafeFree(p_parser->source_embedded);
     SafeFree(p_parser->functions);
     SafeFree(p_parser->access_chains);
+
+    if (IsNotNull(p_parser->physical_pointer_structs)) {
+      SafeFree(p_parser->physical_pointer_structs);
+    }
     p_parser->node_count = 0;
   }
 }
 
-static SpvReflectResult ParseNodes(Parser* p_parser)
-{
+static SpvReflectResult ParseNodes(SpvReflectPrvParser* p_parser) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
 
@@ -596,7 +699,7 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
 
   // Allocate nodes
   p_parser->node_count = node_count;
-  p_parser->nodes = (Node*)calloc(p_parser->node_count, sizeof(*(p_parser->nodes)));
+  p_parser->nodes = (SpvReflectPrvNode*)calloc(p_parser->node_count, sizeof(*(p_parser->nodes)));
   if (IsNull(p_parser->nodes)) {
     return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
   }
@@ -607,8 +710,10 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
     p_parser->nodes[i].decorations.set.value = (uint32_t)INVALID_VALUE;
     p_parser->nodes[i].decorations.binding.value = (uint32_t)INVALID_VALUE;
     p_parser->nodes[i].decorations.location.value = (uint32_t)INVALID_VALUE;
+    p_parser->nodes[i].decorations.component.value = (uint32_t)INVALID_VALUE;
     p_parser->nodes[i].decorations.offset.value = (uint32_t)INVALID_VALUE;
     p_parser->nodes[i].decorations.uav_counter_buffer.value = (uint32_t)INVALID_VALUE;
+    p_parser->nodes[i].decorations.spec_id = (uint32_t)INVALID_VALUE;
     p_parser->nodes[i].decorations.built_in = (SpvBuiltIn)INVALID_VALUE;
   }
   // Mark source file id node
@@ -620,7 +725,7 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
 
   // Allocate access chain
   if (p_parser->access_chain_count > 0) {
-    p_parser->access_chains = (AccessChain*)calloc(p_parser->access_chain_count, sizeof(*(p_parser->access_chains)));
+    p_parser->access_chains = (SpvReflectPrvAccessChain*)calloc(p_parser->access_chain_count, sizeof(*(p_parser->access_chains)));
     if (IsNull(p_parser->access_chains)) {
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
@@ -635,18 +740,18 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
     SpvOp op = (SpvOp)(word & 0xFFFF);
     uint32_t node_word_count = (word >> 16) & 0xFFFF;
 
-    Node* p_node = &(p_parser->nodes[node_index]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[node_index]);
     p_node->op = op;
     p_node->word_offset = spirv_word_index;
     p_node->word_count = node_word_count;
 
     switch (p_node->op) {
-      default: break;
+      default:
+        break;
 
       case SpvOpString: {
         ++(p_parser->string_count);
-      }
-      break;
+      } break;
 
       case SpvOpSource: {
         CHECKED_READU32_CAST(p_parser, p_node->word_offset + 1, SpvSourceLanguage, p_parser->source_language);
@@ -658,65 +763,70 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
           const char* p_source = (const char*)(p_parser->spirv_code + p_node->word_offset + 4);
 
           const size_t source_len = strlen(p_source);
-          char* p_source_temp = (char*)calloc(source_len + 1, sizeof(char*));
+          char* p_source_temp = (char*)calloc(source_len + 1, sizeof(char));
 
           if (IsNull(p_source_temp)) {
             return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
           }
 
-      #ifdef _WIN32
+#ifdef _WIN32
           strcpy_s(p_source_temp, source_len + 1, p_source);
-      #else
+#else
           strcpy(p_source_temp, p_source);
-      #endif
+#endif
 
+          SafeFree(p_parser->source_embedded);
           p_parser->source_embedded = p_source_temp;
         }
-      }
-      break;
+      } break;
 
       case SpvOpSourceContinued: {
         const char* p_source = (const char*)(p_parser->spirv_code + p_node->word_offset + 1);
 
         const size_t source_len = strlen(p_source);
-        const size_t embedded_source_len = strlen(p_parser->source_embedded); 
-        char* p_continued_source = (char*)calloc(source_len + embedded_source_len + 1, sizeof(char*));
+        const size_t embedded_source_len = strlen(p_parser->source_embedded);
+        char* p_continued_source = (char*)calloc(source_len + embedded_source_len + 1, sizeof(char));
 
         if (IsNull(p_continued_source)) {
           return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
         }
 
-    #ifdef _WIN32
+#ifdef _WIN32
         strcpy_s(p_continued_source, embedded_source_len + 1, p_parser->source_embedded);
-        strcat_s(p_continued_source, source_len + 1, p_source);
-    #else
+        strcat_s(p_continued_source, embedded_source_len + source_len + 1, p_source);
+#else
         strcpy(p_continued_source, p_parser->source_embedded);
         strcat(p_continued_source, p_source);
-    #endif
+#endif
 
         SafeFree(p_parser->source_embedded);
         p_parser->source_embedded = p_continued_source;
-      }
-      break;
+      } break;
 
       case SpvOpEntryPoint: {
         ++(p_parser->entry_point_count);
-      }
-      break;
+      } break;
+
+      case SpvOpCapability: {
+        CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->capability);
+        ++(p_parser->capability_count);
+      } break;
 
       case SpvOpName:
-      case SpvOpMemberName:
-      {
+      case SpvOpMemberName: {
         uint32_t member_offset = (p_node->op == SpvOpMemberName) ? 1 : 0;
         uint32_t name_start = p_node->word_offset + member_offset + 2;
         p_node->name = (const char*)(p_parser->spirv_code + name_start);
-      }
-      break;
+      } break;
 
-      case SpvOpTypeStruct:
-      {
+      case SpvOpTypeStruct: {
         p_node->member_count = p_node->word_count - 2;
-      } // Fall through
+        FALLTHROUGH;
+      }  // Fall through
+
+      // This is all the rest of OpType* that need to be tracked
+      // Possible new extensions might expose new type, will need to be added
+      // here
       case SpvOpTypeVoid:
       case SpvOpTypeBool:
       case SpvOpTypeInt:
@@ -733,11 +843,12 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
       case SpvOpTypePipe:
       case SpvOpTypeAccelerationStructureKHR:
       case SpvOpTypeRayQueryKHR:
-      {
+      case SpvOpTypeHitObjectNV:
+      case SpvOpTypeCooperativeMatrixNV:
+      case SpvOpTypeCooperativeMatrixKHR: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
         p_node->is_type = true;
-      }
-      break;
+      } break;
 
       case SpvOpTypeImage: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
@@ -749,46 +860,47 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
         CHECKED_READU32(p_parser, p_node->word_offset + 7, p_node->image_traits.sampled);
         CHECKED_READU32(p_parser, p_node->word_offset + 8, p_node->image_traits.image_format);
         p_node->is_type = true;
-      }
-      break;
+      } break;
 
       case SpvOpTypeSampledImage: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->image_type_id);
         p_node->is_type = true;
-      }
-      break;
+      } break;
 
-      case SpvOpTypeArray:  {
+      case SpvOpTypeArray: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->array_traits.element_type_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 3, p_node->array_traits.length_id);
         p_node->is_type = true;
-      }
-      break;
+      } break;
 
-      case SpvOpTypeRuntimeArray:  {
+      case SpvOpTypeRuntimeArray: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->array_traits.element_type_id);
         p_node->is_type = true;
-      }
-      break;
+      } break;
 
       case SpvOpTypePointer: {
-        CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
+        uint32_t result_id;
+        CHECKED_READU32(p_parser, p_node->word_offset + 1, result_id);
+        // Look for forward pointer. Clear result id if found
+        SpvReflectPrvNode* p_fwd_node = FindNode(p_parser, result_id);
+        if (p_fwd_node) {
+          p_fwd_node->result_id = 0;
+        }
+        // Register pointer type
+        p_node->result_id = result_id;
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->storage_class);
         CHECKED_READU32(p_parser, p_node->word_offset + 3, p_node->type_id);
         p_node->is_type = true;
-      }
-      break;
+      } break;
 
-      case SpvOpTypeForwardPointer:
-      {
+      case SpvOpTypeForwardPointer: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->storage_class);
         p_node->is_type = true;
-      }
-      break;
+      } break;
 
       case SpvOpConstantTrue:
       case SpvOpConstantFalse:
@@ -798,8 +910,7 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
       case SpvOpConstantNull: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
-      }
-      break;
+      } break;
 
       case SpvOpSpecConstantTrue:
       case SpvOpSpecConstantFalse:
@@ -808,28 +919,22 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
       case SpvOpSpecConstantOp: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
-      }
-      break;
+      } break;
 
-      case SpvOpVariable:
-      {
+      case SpvOpVariable: {
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->type_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 3, p_node->storage_class);
-      }
-      break;
+      } break;
 
-      case SpvOpLoad:
-      {
+      case SpvOpLoad: {
         // Only load enough so OpDecorate can reference the node, skip the remaining operands.
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_node->result_type_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
-      }
-      break;
+      } break;
 
-      case SpvOpAccessChain:
-      {
-        AccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
+      case SpvOpAccessChain: {
+        SpvReflectPrvAccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
         CHECKED_READU32(p_parser, p_node->word_offset + 1, p_access_chain->result_type_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_access_chain->result_id);
         CHECKED_READU32(p_parser, p_node->word_offset + 3, p_access_chain->base_id);
@@ -840,7 +945,7 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
         p_access_chain->index_count = (node_word_count - SPIRV_ACCESS_CHAIN_INDEX_OFFSET);
         if (p_access_chain->index_count > 0) {
           p_access_chain->indexes = (uint32_t*)calloc(p_access_chain->index_count, sizeof(*(p_access_chain->indexes)));
-          if (IsNull( p_access_chain->indexes)) {
+          if (IsNull(p_access_chain->indexes)) {
             return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
           }
           // Parse any index values for access chain
@@ -849,8 +954,9 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
             uint32_t index_id = 0;
             CHECKED_READU32(p_parser, p_node->word_offset + SPIRV_ACCESS_CHAIN_INDEX_OFFSET + index_index, index_id);
             // Find OpConstant node that contains index value
-            Node* p_index_value_node = FindNode(p_parser, index_id);
-            if ((p_index_value_node != NULL) && (p_index_value_node->op == SpvOpConstant)) {
+            SpvReflectPrvNode* p_index_value_node = FindNode(p_parser, index_id);
+            if ((p_index_value_node != NULL) &&
+                (p_index_value_node->op == SpvOpConstant || p_index_value_node->op == SpvOpSpecConstant)) {
               // Read index value
               uint32_t index_value = UINT32_MAX;
               CHECKED_READU32(p_parser, p_index_value_node->word_offset + 3, index_value);
@@ -861,34 +967,41 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
           }
         }
         ++access_chain_index;
-      }
-      break;
+      } break;
 
-      case SpvOpFunction:
-      {
+      case SpvOpFunction: {
         CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
         // Count function definitions, not function declarations.  To determine
         // the difference, set an in-function variable, and then if an OpLabel
         // is reached before the end of the function increment the function
         // count.
         function_node = node_index;
-      }
-      break;
+      } break;
 
-      case SpvOpLabel:
-      {
+      case SpvOpLabel: {
         if (function_node != (uint32_t)INVALID_VALUE) {
-          Node* p_func_node = &(p_parser->nodes[function_node]);
+          SpvReflectPrvNode* p_func_node = &(p_parser->nodes[function_node]);
           CHECKED_READU32(p_parser, p_func_node->word_offset + 2, p_func_node->result_id);
           ++(p_parser->function_count);
         }
-      } // Fall through
+        FALLTHROUGH;
+      }  // Fall through
 
-      case SpvOpFunctionEnd:
-      {
+      case SpvOpFunctionEnd: {
         function_node = (uint32_t)INVALID_VALUE;
-      }
-      break;
+      } break;
+      case SpvOpFunctionParameter: {
+        CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
+      } break;
+      case SpvOpBitcast:
+      case SpvOpShiftRightLogical:
+      case SpvOpIAdd:
+      case SpvOpISub:
+      case SpvOpIMul:
+      case SpvOpUDiv:
+      case SpvOpSDiv: {
+        CHECKED_READU32(p_parser, p_node->word_offset + 2, p_node->result_id);
+      } break;
     }
 
     if (p_node->is_type) {
@@ -902,8 +1015,7 @@ static SpvReflectResult ParseNodes(Parser* p_parser)
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseStrings(Parser* p_parser)
-{
+static SpvReflectResult ParseStrings(SpvReflectPrvParser* p_parser) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
   assert(IsNotNull(p_parser->nodes));
@@ -915,11 +1027,11 @@ static SpvReflectResult ParseStrings(Parser* p_parser)
 
   if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
     // Allocate string storage
-    p_parser->strings = (String*)calloc(p_parser->string_count, sizeof(*(p_parser->strings)));  
+    p_parser->strings = (SpvReflectPrvString*)calloc(p_parser->string_count, sizeof(*(p_parser->strings)));
 
     uint32_t string_index = 0;
     for (size_t i = 0; i < p_parser->node_count; ++i) {
-      Node* p_node = &(p_parser->nodes[i]);
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
       if (p_node->op != SpvOpString) {
         continue;
       }
@@ -931,7 +1043,7 @@ static SpvReflectResult ParseStrings(Parser* p_parser)
       }
 
       // Result id
-      String* p_string = &(p_parser->strings[string_index]);
+      SpvReflectPrvString* p_string = &(p_parser->strings[string_index]);
       CHECKED_READU32(p_parser, p_node->word_offset + 1, p_string->result_id);
 
       // String
@@ -942,12 +1054,11 @@ static SpvReflectResult ParseStrings(Parser* p_parser)
       ++string_index;
     }
   }
-  
+
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseSource(Parser* p_parser, SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseSource(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
 
@@ -955,7 +1066,7 @@ static SpvReflectResult ParseSource(Parser* p_parser, SpvReflectShaderModule* p_
     // Source file
     if (IsNotNull(p_parser->strings)) {
       for (uint32_t i = 0; i < p_parser->string_count; ++i) {
-        String* p_string = &(p_parser->strings[i]);
+        SpvReflectPrvString* p_string = &(p_parser->strings[i]);
         if (p_string->result_id == p_parser->source_file_id) {
           p_module->source_file = p_string->string;
           break;
@@ -963,21 +1074,20 @@ static SpvReflectResult ParseSource(Parser* p_parser, SpvReflectShaderModule* p_
       }
     }
 
-    //Source code
-    if (IsNotNull(p_parser->source_embedded))
-    {
+    // Source code
+    if (IsNotNull(p_parser->source_embedded)) {
       const size_t source_len = strlen(p_parser->source_embedded);
-      char* p_source = (char*)calloc(source_len + 1, sizeof(char*));
+      char* p_source = (char*)calloc(source_len + 1, sizeof(char));
 
       if (IsNull(p_source)) {
         return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
       }
 
-    #ifdef _WIN32
+#ifdef _WIN32
       strcpy_s(p_source, source_len + 1, p_parser->source_embedded);
-    #else
+#else
       strcpy(p_source, p_parser->source_embedded);
-    #endif
+#endif
 
       p_module->source_source = p_source;
     }
@@ -986,23 +1096,28 @@ static SpvReflectResult ParseSource(Parser* p_parser, SpvReflectShaderModule* p_
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseFunction(Parser* p_parser, Node* p_func_node, Function* p_func, size_t first_label_index)
-{
+static SpvReflectResult ParseFunction(SpvReflectPrvParser* p_parser, SpvReflectPrvNode* p_func_node, SpvReflectPrvFunction* p_func,
+                                      size_t first_label_index) {
   p_func->id = p_func_node->result_id;
 
+  p_func->parameter_count = 0;
   p_func->callee_count = 0;
-  p_func->accessed_ptr_count = 0;
+  p_func->accessed_variable_count = 0;
 
+  // First get count to know how much to allocate
   for (size_t i = first_label_index; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
     if (p_node->op == SpvOpFunctionEnd) {
       break;
     }
     switch (p_node->op) {
+      case SpvOpFunctionParameter: {
+        ++(p_func->parameter_count);
+      } break;
       case SpvOpFunctionCall: {
+        p_func->accessed_variable_count += p_node->word_count - 4;
         ++(p_func->callee_count);
-      }
-      break;
+      } break;
       case SpvOpLoad:
       case SpvOpAccessChain:
       case SpvOpInBoundsAccessChain:
@@ -1011,50 +1126,71 @@ static SpvReflectResult ParseFunction(Parser* p_parser, Node* p_func_node, Funct
       case SpvOpGenericPtrMemSemantics:
       case SpvOpInBoundsPtrAccessChain:
       case SpvOpStore:
-      {
-        ++(p_func->accessed_ptr_count);
-      }
-      break;
+      case SpvOpImageTexelPointer: {
+        ++(p_func->accessed_variable_count);
+      } break;
       case SpvOpCopyMemory:
-      case SpvOpCopyMemorySized:
-      {
-        p_func->accessed_ptr_count += 2;
-      }
-      break;
-      default: break;
+      case SpvOpCopyMemorySized: {
+        p_func->accessed_variable_count += 2;
+      } break;
+      default:
+        break;
+    }
+  }
+
+  if (p_func->parameter_count > 0) {
+    p_func->parameters = (uint32_t*)calloc(p_func->parameter_count, sizeof(*(p_func->parameters)));
+    if (IsNull(p_func->parameters)) {
+      return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
   }
 
   if (p_func->callee_count > 0) {
-    p_func->callees = (uint32_t*)calloc(p_func->callee_count,
-                                        sizeof(*(p_func->callees)));
+    p_func->callees = (uint32_t*)calloc(p_func->callee_count, sizeof(*(p_func->callees)));
     if (IsNull(p_func->callees)) {
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
   }
 
-  if (p_func->accessed_ptr_count > 0) {
-    p_func->accessed_ptrs = (uint32_t*)calloc(p_func->accessed_ptr_count,
-                                              sizeof(*(p_func->accessed_ptrs)));
-    if (IsNull(p_func->accessed_ptrs)) {
+  if (p_func->accessed_variable_count > 0) {
+    p_func->accessed_variables =
+        (SpvReflectPrvAccessedVariable*)calloc(p_func->accessed_variable_count, sizeof(*(p_func->accessed_variables)));
+    if (IsNull(p_func->accessed_variables)) {
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
   }
 
+  p_func->parameter_count = 0;
   p_func->callee_count = 0;
-  p_func->accessed_ptr_count = 0;
+  p_func->accessed_variable_count = 0;
+  // Now have allocation, fill in values
   for (size_t i = first_label_index; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
     if (p_node->op == SpvOpFunctionEnd) {
       break;
     }
     switch (p_node->op) {
+      case SpvOpFunctionParameter: {
+        CHECKED_READU32(p_parser, p_node->word_offset + 2, p_func->parameters[p_func->parameter_count]);
+        (++p_func->parameter_count);
+      } break;
       case SpvOpFunctionCall: {
-        CHECKED_READU32(p_parser, p_node->word_offset + 3,
-                        p_func->callees[p_func->callee_count]);
+        CHECKED_READU32(p_parser, p_node->word_offset + 3, p_func->callees[p_func->callee_count]);
+        const uint32_t result_index = p_node->word_offset + 2;
+        for (uint32_t j = 0, parameter_count = p_node->word_count - 4; j < parameter_count; j++) {
+          const uint32_t ptr_index = p_node->word_offset + 4 + j;
+          SpvReflectPrvAccessedVariable* access_ptr = &p_func->accessed_variables[p_func->accessed_variable_count];
+
+          access_ptr->p_node = p_node;
+          // Need to track Result ID as not sure there has been any memory access through here yet
+          CHECKED_READU32(p_parser, result_index, access_ptr->result_id);
+          CHECKED_READU32(p_parser, ptr_index, access_ptr->variable_ptr);
+          access_ptr->function_id = p_func->callees[p_func->callee_count];
+          access_ptr->function_parameter_index = j;
+          (++p_func->accessed_variable_count);
+        }
         (++p_func->callee_count);
-      }
-      break;
+      } break;
       case SpvOpLoad:
       case SpvOpAccessChain:
       case SpvOpInBoundsAccessChain:
@@ -1062,60 +1198,58 @@ static SpvReflectResult ParseFunction(Parser* p_parser, Node* p_func_node, Funct
       case SpvOpArrayLength:
       case SpvOpGenericPtrMemSemantics:
       case SpvOpInBoundsPtrAccessChain:
-      {
-        CHECKED_READU32(p_parser, p_node->word_offset + 3,
-                        p_func->accessed_ptrs[p_func->accessed_ptr_count]);
-        (++p_func->accessed_ptr_count);
-      }
-      break;
-      case SpvOpStore:
-      {
-        CHECKED_READU32(p_parser, p_node->word_offset + 2,
-                        p_func->accessed_ptrs[p_func->accessed_ptr_count]);
-        (++p_func->accessed_ptr_count);
-      }
-      break;
+      case SpvOpImageTexelPointer: {
+        const uint32_t result_index = p_node->word_offset + 2;
+        const uint32_t ptr_index = p_node->word_offset + 3;
+        SpvReflectPrvAccessedVariable* access_ptr = &p_func->accessed_variables[p_func->accessed_variable_count];
+
+        access_ptr->p_node = p_node;
+        // Need to track Result ID as not sure there has been any memory access through here yet
+        CHECKED_READU32(p_parser, result_index, access_ptr->result_id);
+        CHECKED_READU32(p_parser, ptr_index, access_ptr->variable_ptr);
+        (++p_func->accessed_variable_count);
+      } break;
+      case SpvOpStore: {
+        const uint32_t result_index = p_node->word_offset + 2;
+        CHECKED_READU32(p_parser, result_index, p_func->accessed_variables[p_func->accessed_variable_count].variable_ptr);
+        p_func->accessed_variables[p_func->accessed_variable_count].p_node = p_node;
+        (++p_func->accessed_variable_count);
+      } break;
       case SpvOpCopyMemory:
-      case SpvOpCopyMemorySized:
-      {
+      case SpvOpCopyMemorySized: {
+        // There is no result_id or node, being zero is same as being invalid
+        CHECKED_READU32(p_parser, p_node->word_offset + 1,
+                        p_func->accessed_variables[p_func->accessed_variable_count].variable_ptr);
+        (++p_func->accessed_variable_count);
         CHECKED_READU32(p_parser, p_node->word_offset + 2,
-                        p_func->accessed_ptrs[p_func->accessed_ptr_count]);
-        (++p_func->accessed_ptr_count);
-        CHECKED_READU32(p_parser, p_node->word_offset + 3,
-                        p_func->accessed_ptrs[p_func->accessed_ptr_count]);
-        (++p_func->accessed_ptr_count);
-      }
-      break;
-      default: break;
+                        p_func->accessed_variables[p_func->accessed_variable_count].variable_ptr);
+        (++p_func->accessed_variable_count);
+      } break;
+      default:
+        break;
     }
   }
 
   if (p_func->callee_count > 0) {
-    qsort(p_func->callees, p_func->callee_count,
-          sizeof(*(p_func->callees)), SortCompareUint32);
+    qsort(p_func->callees, p_func->callee_count, sizeof(*(p_func->callees)), SortCompareUint32);
   }
-  p_func->callee_count = (uint32_t)DedupSortedUint32(p_func->callees,
-                                                     p_func->callee_count);
+  p_func->callee_count = (uint32_t)DedupSortedUint32(p_func->callees, p_func->callee_count);
 
-  if (p_func->accessed_ptr_count > 0) {
-    qsort(p_func->accessed_ptrs, p_func->accessed_ptr_count,
-          sizeof(*(p_func->accessed_ptrs)), SortCompareUint32);
+  if (p_func->accessed_variable_count > 0) {
+    qsort(p_func->accessed_variables, p_func->accessed_variable_count, sizeof(*(p_func->accessed_variables)),
+          SortCompareAccessedVariable);
   }
-  p_func->accessed_ptr_count = (uint32_t)DedupSortedUint32(p_func->accessed_ptrs,
-                                                           p_func->accessed_ptr_count);
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static int SortCompareFunctions(const void* a, const void* b)
-{
-  const Function* af = (const Function*)a;
-  const Function* bf = (const Function*)b;
+static int SortCompareFunctions(const void* a, const void* b) {
+  const SpvReflectPrvFunction* af = (const SpvReflectPrvFunction*)a;
+  const SpvReflectPrvFunction* bf = (const SpvReflectPrvFunction*)b;
   return (int)af->id - (int)bf->id;
 }
 
-static SpvReflectResult ParseFunctions(Parser* p_parser)
-{
+static SpvReflectResult ParseFunctions(SpvReflectPrvParser* p_parser) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
   assert(IsNotNull(p_parser->nodes));
@@ -1125,29 +1259,26 @@ static SpvReflectResult ParseFunctions(Parser* p_parser)
       return SPV_REFLECT_RESULT_SUCCESS;
     }
 
-    p_parser->functions = (Function*)calloc(p_parser->function_count,
-                                            sizeof(*(p_parser->functions)));
+    p_parser->functions = (SpvReflectPrvFunction*)calloc(p_parser->function_count, sizeof(*(p_parser->functions)));
     if (IsNull(p_parser->functions)) {
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
 
     size_t function_index = 0;
     for (size_t i = 0; i < p_parser->node_count; ++i) {
-      Node* p_node = &(p_parser->nodes[i]);
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
       if (p_node->op != SpvOpFunction) {
         continue;
       }
 
       // Skip over function declarations that aren't definitions
       bool func_definition = false;
-      // Intentionally reuse i to avoid iterating over these nodes more than
-      // once
-      for (; i < p_parser->node_count; ++i) {
-        if (p_parser->nodes[i].op == SpvOpLabel) {
+      for (size_t j = i; j < p_parser->node_count; ++j) {
+        if (p_parser->nodes[j].op == SpvOpLabel) {
           func_definition = true;
           break;
         }
-        if (p_parser->nodes[i].op == SpvOpFunctionEnd) {
+        if (p_parser->nodes[j].op == SpvOpFunctionEnd) {
           break;
         }
       }
@@ -1155,7 +1286,7 @@ static SpvReflectResult ParseFunctions(Parser* p_parser)
         continue;
       }
 
-      Function* p_function = &(p_parser->functions[function_index]);
+      SpvReflectPrvFunction* p_function = &(p_parser->functions[function_index]);
 
       SpvReflectResult result = ParseFunction(p_parser, p_node, p_function, i);
       if (result != SPV_REFLECT_RESULT_SUCCESS) {
@@ -1165,18 +1296,16 @@ static SpvReflectResult ParseFunctions(Parser* p_parser)
       ++function_index;
     }
 
-    qsort(p_parser->functions, p_parser->function_count,
-          sizeof(*(p_parser->functions)), SortCompareFunctions);
+    qsort(p_parser->functions, p_parser->function_count, sizeof(*(p_parser->functions)), SortCompareFunctions);
 
     // Once they're sorted, link the functions with pointers to improve graph
     // traversal efficiency
     for (size_t i = 0; i < p_parser->function_count; ++i) {
-      Function* p_func = &(p_parser->functions[i]);
+      SpvReflectPrvFunction* p_func = &(p_parser->functions[i]);
       if (p_func->callee_count == 0) {
         continue;
       }
-      p_func->callee_ptrs = (Function**)calloc(p_func->callee_count,
-                                               sizeof(*(p_func->callee_ptrs)));
+      p_func->callee_ptrs = (SpvReflectPrvFunction**)calloc(p_func->callee_count, sizeof(*(p_func->callee_ptrs)));
       for (size_t j = 0, k = 0; j < p_func->callee_count; ++j) {
         while (p_parser->functions[k].id != p_func->callees[j]) {
           ++k;
@@ -1193,15 +1322,14 @@ static SpvReflectResult ParseFunctions(Parser* p_parser)
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseMemberCounts(Parser* p_parser)
-{
+static SpvReflectResult ParseMemberCounts(SpvReflectPrvParser* p_parser) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
   assert(IsNotNull(p_parser->nodes));
 
   if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
     for (size_t i = 0; i < p_parser->node_count; ++i) {
-      Node* p_node = &(p_parser->nodes[i]);
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
       if ((p_node->op != SpvOpMemberName) && (p_node->op != SpvOpMemberDecorate)) {
         continue;
       }
@@ -1210,7 +1338,7 @@ static SpvReflectResult ParseMemberCounts(Parser* p_parser)
       uint32_t member_index = (uint32_t)INVALID_VALUE;
       CHECKED_READU32(p_parser, p_node->word_offset + 1, target_id);
       CHECKED_READU32(p_parser, p_node->word_offset + 2, member_index);
-      Node* p_target_node = FindNode(p_parser, target_id);
+      SpvReflectPrvNode* p_target_node = FindNode(p_parser, target_id);
       // Not all nodes get parsed, so FindNode returning NULL is expected.
       if (IsNull(p_target_node)) {
         continue;
@@ -1224,17 +1352,17 @@ static SpvReflectResult ParseMemberCounts(Parser* p_parser)
     }
 
     for (uint32_t i = 0; i < p_parser->node_count; ++i) {
-      Node* p_node = &(p_parser->nodes[i]);
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
       if (p_node->member_count == 0) {
         continue;
       }
 
-      p_node->member_names = (const char **)calloc(p_node->member_count, sizeof(*(p_node->member_names)));
+      p_node->member_names = (const char**)calloc(p_node->member_count, sizeof(*(p_node->member_names)));
       if (IsNull(p_node->member_names)) {
         return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
       }
 
-      p_node->member_decorations = (Decorations*)calloc(p_node->member_count, sizeof(*(p_node->member_decorations)));
+      p_node->member_decorations = (SpvReflectPrvDecorations*)calloc(p_node->member_count, sizeof(*(p_node->member_decorations)));
       if (IsNull(p_node->member_decorations)) {
         return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
       }
@@ -1243,22 +1371,21 @@ static SpvReflectResult ParseMemberCounts(Parser* p_parser)
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseNames(Parser* p_parser)
-{
+static SpvReflectResult ParseNames(SpvReflectPrvParser* p_parser) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->spirv_code));
   assert(IsNotNull(p_parser->nodes));
 
   if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
     for (size_t i = 0; i < p_parser->node_count; ++i) {
-      Node* p_node = &(p_parser->nodes[i]);
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
       if ((p_node->op != SpvOpName) && (p_node->op != SpvOpMemberName)) {
         continue;
       }
 
       uint32_t target_id = 0;
       CHECKED_READU32(p_parser, p_node->word_offset + 1, target_id);
-      Node* p_target_node = FindNode(p_parser, target_id);
+      SpvReflectPrvNode* p_target_node = FindNode(p_parser, target_id);
       // Not all nodes get parsed, so FindNode returning NULL is expected.
       if (IsNull(p_target_node)) {
         continue;
@@ -1277,18 +1404,27 @@ static SpvReflectResult ParseNames(Parser* p_parser)
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseDecorations(Parser* p_parser)
-{
-  for (uint32_t i = 0; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+// Returns true if user_type matches pattern or if user_type begins with pattern and the next character is ':'
+// For example, UserTypeMatches("rwbuffer", "rwbuffer") will be true, UserTypeMatches("rwbuffer", "rwbuffer:<S>") will be true, and
+// UserTypeMatches("rwbuffer", "rwbufferfoo") will be false.
+static bool UserTypeMatches(const char* user_type, const char* pattern) {
+  const size_t pattern_length = strlen(pattern);
+  if (strncmp(user_type, pattern, pattern_length) == 0) {
+    if (user_type[pattern_length] == ':' || user_type[pattern_length] == '\0') {
+      return true;
+    }
+  }
+  return false;
+}
 
-    if (((uint32_t)p_node->op != (uint32_t)SpvOpDecorate) &&
-        ((uint32_t)p_node->op != (uint32_t)SpvOpMemberDecorate) &&
-        ((uint32_t)p_node->op != (uint32_t)SpvReflectOpDecorateId) &&
-        ((uint32_t)p_node->op != (uint32_t)SpvReflectOpDecorateStringGOOGLE) &&
-        ((uint32_t)p_node->op != (uint32_t)SpvReflectOpMemberDecorateStringGOOGLE))
-    {
-     continue;
+static SpvReflectResult ParseDecorations(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
+  uint32_t spec_constant_count = 0;
+  for (uint32_t i = 0; i < p_parser->node_count; ++i) {
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
+
+    if ((p_node->op != SpvOpDecorate) && (p_node->op != SpvOpMemberDecorate) && (p_node->op != SpvOpDecorateId) &&
+        (p_node->op != SpvOpDecorateString) && (p_node->op != SpvOpMemberDecorateString)) {
+      continue;
     }
 
     // Need to adjust the read offset if this is a member decoration
@@ -1307,8 +1443,8 @@ static SpvReflectResult ParseDecorations(Parser* p_parser)
     switch (decoration) {
       default: {
         skip = true;
-      }
-      break; 
+      } break;
+      case SpvDecorationRelaxedPrecision:
       case SpvDecorationBlock:
       case SpvDecorationBufferBlock:
       case SpvDecorationColMajor:
@@ -1319,31 +1455,44 @@ static SpvReflectResult ParseDecorations(Parser* p_parser)
       case SpvDecorationNoPerspective:
       case SpvDecorationFlat:
       case SpvDecorationNonWritable:
+      case SpvDecorationNonReadable:
+      case SpvDecorationPatch:
+      case SpvDecorationPerVertexKHR:
+      case SpvDecorationPerTaskNV:
       case SpvDecorationLocation:
+      case SpvDecorationComponent:
       case SpvDecorationBinding:
       case SpvDecorationDescriptorSet:
       case SpvDecorationOffset:
       case SpvDecorationInputAttachmentIndex:
-      case SpvReflectDecorationHlslCounterBufferGOOGLE:
-      case SpvReflectDecorationHlslSemanticGOOGLE: {
+      case SpvDecorationSpecId:
+      case SpvDecorationWeightTextureQCOM:
+      case SpvDecorationBlockMatchTextureQCOM:
+      case SpvDecorationUserTypeGOOGLE:
+      case SpvDecorationHlslCounterBufferGOOGLE:
+      case SpvDecorationHlslSemanticGOOGLE: {
         skip = false;
-      }
-      break;    
+      } break;
     }
     if (skip) {
       continue;
-    }  
-    
-    // Find target target node 
+    }
+
+    // Find target node
     uint32_t target_id = 0;
     CHECKED_READU32(p_parser, p_node->word_offset + 1, target_id);
-    Node* p_target_node = FindNode(p_parser, target_id);
+    SpvReflectPrvNode* p_target_node = FindNode(p_parser, target_id);
     if (IsNull(p_target_node)) {
+      if ((p_node->op == (uint32_t)SpvOpDecorate) && (decoration == SpvDecorationRelaxedPrecision)) {
+        // Many OPs can be decorated that we don't care about. Ignore those.
+        // See https://github.com/KhronosGroup/SPIRV-Reflect/issues/134
+        continue;
+      }
       return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
     }
     // Get decorations
-    Decorations* p_target_decorations = &(p_target_node->decorations);
-    // Update pointer if this is a member member decoration
+    SpvReflectPrvDecorations* p_target_decorations = &(p_target_node->decorations);
+    // Update pointer if this is a member decoration
     if (p_node->op == SpvOpMemberDecorate) {
       uint32_t member_index = (uint32_t)INVALID_VALUE;
       CHECKED_READU32(p_parser, p_node->word_offset + 2, member_index);
@@ -1351,121 +1500,252 @@ static SpvReflectResult ParseDecorations(Parser* p_parser)
     }
 
     switch (decoration) {
-      default: break;
+      default:
+        break;
+
+      case SpvDecorationRelaxedPrecision: {
+        p_target_decorations->is_relaxed_precision = true;
+      } break;
 
       case SpvDecorationBlock: {
         p_target_decorations->is_block = true;
-      }
-      break;
+      } break;
 
       case SpvDecorationBufferBlock: {
         p_target_decorations->is_buffer_block = true;
-      }
-      break;
+      } break;
 
       case SpvDecorationColMajor: {
         p_target_decorations->is_column_major = true;
-      }
-      break;
+      } break;
 
       case SpvDecorationRowMajor: {
         p_target_decorations->is_row_major = true;
-      }
-      break;
+      } break;
 
       case SpvDecorationArrayStride: {
         uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->array_stride);
-      }
-      break;
+      } break;
 
       case SpvDecorationMatrixStride: {
         uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->matrix_stride);
-      }
-      break;
+      } break;
 
       case SpvDecorationBuiltIn: {
         p_target_decorations->is_built_in = true;
         uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32_CAST(p_parser, word_offset, SpvBuiltIn, p_target_decorations->built_in);
-      }
-      break;
+      } break;
 
       case SpvDecorationNoPerspective: {
         p_target_decorations->is_noperspective = true;
-      }
-      break;
+      } break;
 
       case SpvDecorationFlat: {
         p_target_decorations->is_flat = true;
-      }
-      break;
+      } break;
 
       case SpvDecorationNonWritable: {
         p_target_decorations->is_non_writable = true;
-      }
-      break;
+      } break;
+
+      case SpvDecorationNonReadable: {
+        p_target_decorations->is_non_readable = true;
+      } break;
+
+      case SpvDecorationPatch: {
+        p_target_decorations->is_patch = true;
+      } break;
+
+      case SpvDecorationPerVertexKHR: {
+        p_target_decorations->is_per_vertex = true;
+      } break;
+
+      case SpvDecorationPerTaskNV: {
+        p_target_decorations->is_per_task = true;
+      } break;
 
       case SpvDecorationLocation: {
         uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->location.value);
         p_target_decorations->location.word_offset = word_offset;
-      }
-      break;
+      } break;
+
+      case SpvDecorationComponent: {
+        uint32_t word_offset = p_node->word_offset + member_offset + 3;
+        CHECKED_READU32(p_parser, word_offset, p_target_decorations->component.value);
+        p_target_decorations->component.word_offset = word_offset;
+      } break;
 
       case SpvDecorationBinding: {
-        uint32_t word_offset = p_node->word_offset + member_offset+ 3;
+        uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->binding.value);
         p_target_decorations->binding.word_offset = word_offset;
-      }
-      break;
+      } break;
 
       case SpvDecorationDescriptorSet: {
-        uint32_t word_offset = p_node->word_offset + member_offset+ 3;
+        uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->set.value);
         p_target_decorations->set.word_offset = word_offset;
-      }
-      break;
+      } break;
 
       case SpvDecorationOffset: {
-        uint32_t word_offset = p_node->word_offset + member_offset+ 3;
+        uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->offset.value);
         p_target_decorations->offset.word_offset = word_offset;
-      }
-      break;
+      } break;
 
       case SpvDecorationInputAttachmentIndex: {
-        uint32_t word_offset = p_node->word_offset + member_offset+ 3;
+        uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->input_attachment_index.value);
         p_target_decorations->input_attachment_index.word_offset = word_offset;
-      }
-      break;
+      } break;
 
-      case SpvReflectDecorationHlslCounterBufferGOOGLE: {
-        uint32_t word_offset = p_node->word_offset + member_offset+ 3;
+      case SpvDecorationSpecId: {
+        spec_constant_count++;
+      } break;
+
+      case SpvDecorationHlslCounterBufferGOOGLE: {
+        uint32_t word_offset = p_node->word_offset + member_offset + 3;
         CHECKED_READU32(p_parser, word_offset, p_target_decorations->uav_counter_buffer.value);
         p_target_decorations->uav_counter_buffer.word_offset = word_offset;
-      }
-      break;
+      } break;
 
-      case SpvReflectDecorationHlslSemanticGOOGLE: {
+      case SpvDecorationHlslSemanticGOOGLE: {
         uint32_t word_offset = p_node->word_offset + member_offset + 3;
         p_target_decorations->semantic.value = (const char*)(p_parser->spirv_code + word_offset);
         p_target_decorations->semantic.word_offset = word_offset;
+      } break;
+
+      case SpvDecorationWeightTextureQCOM: {
+        p_target_decorations->is_weight_texture = true;
+      } break;
+
+      case SpvDecorationBlockMatchTextureQCOM: {
+        p_target_decorations->is_block_match_texture = true;
+      } break;
+    }
+
+    if (p_node->op == SpvOpDecorateString && decoration == SpvDecorationUserTypeGOOGLE) {
+      uint32_t terminator = 0;
+      SpvReflectResult result = ReadStr(p_parser, p_node->word_offset + 3, 0, p_node->word_count, &terminator, NULL);
+      if (result != SPV_REFLECT_RESULT_SUCCESS) {
+        return result;
+      }
+      const char* name = (const char*)(p_parser->spirv_code + p_node->word_offset + 3);
+      if (UserTypeMatches(name, "cbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_CBUFFER;
+      } else if (UserTypeMatches(name, "tbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TBUFFER;
+      } else if (UserTypeMatches(name, "appendstructuredbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_APPEND_STRUCTURED_BUFFER;
+      } else if (UserTypeMatches(name, "buffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_BUFFER;
+      } else if (UserTypeMatches(name, "byteaddressbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_BYTE_ADDRESS_BUFFER;
+      } else if (UserTypeMatches(name, "constantbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_CONSTANT_BUFFER;
+      } else if (UserTypeMatches(name, "consumestructuredbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_CONSUME_STRUCTURED_BUFFER;
+      } else if (UserTypeMatches(name, "inputpatch")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_INPUT_PATCH;
+      } else if (UserTypeMatches(name, "outputpatch")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_OUTPUT_PATCH;
+      } else if (UserTypeMatches(name, "rasterizerorderedbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BUFFER;
+      } else if (UserTypeMatches(name, "rasterizerorderedbyteaddressbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BYTE_ADDRESS_BUFFER;
+      } else if (UserTypeMatches(name, "rasterizerorderedstructuredbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_STRUCTURED_BUFFER;
+      } else if (UserTypeMatches(name, "rasterizerorderedtexture1d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D;
+      } else if (UserTypeMatches(name, "rasterizerorderedtexture1darray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D_ARRAY;
+      } else if (UserTypeMatches(name, "rasterizerorderedtexture2d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D;
+      } else if (UserTypeMatches(name, "rasterizerorderedtexture2darray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D_ARRAY;
+      } else if (UserTypeMatches(name, "rasterizerorderedtexture3d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_3D;
+      } else if (UserTypeMatches(name, "raytracingaccelerationstructure")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RAYTRACING_ACCELERATION_STRUCTURE;
+      } else if (UserTypeMatches(name, "rwbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_BUFFER;
+      } else if (UserTypeMatches(name, "rwbyteaddressbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_BYTE_ADDRESS_BUFFER;
+      } else if (UserTypeMatches(name, "rwstructuredbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_STRUCTURED_BUFFER;
+      } else if (UserTypeMatches(name, "rwtexture1d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D;
+      } else if (UserTypeMatches(name, "rwtexture1darray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D_ARRAY;
+      } else if (UserTypeMatches(name, "rwtexture2d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D;
+      } else if (UserTypeMatches(name, "rwtexture2darray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D_ARRAY;
+      } else if (UserTypeMatches(name, "rwtexture3d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_RW_TEXTURE_3D;
+      } else if (UserTypeMatches(name, "structuredbuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_STRUCTURED_BUFFER;
+      } else if (UserTypeMatches(name, "subpassinput")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_SUBPASS_INPUT;
+      } else if (UserTypeMatches(name, "subpassinputms")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_SUBPASS_INPUT_MS;
+      } else if (UserTypeMatches(name, "texture1d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_1D;
+      } else if (UserTypeMatches(name, "texture1darray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_1D_ARRAY;
+      } else if (UserTypeMatches(name, "texture2d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2D;
+      } else if (UserTypeMatches(name, "texture2darray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2D_ARRAY;
+      } else if (UserTypeMatches(name, "texture2dms")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2DMS;
+      } else if (UserTypeMatches(name, "texture2dmsarray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_2DMS_ARRAY;
+      } else if (UserTypeMatches(name, "texture3d")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_3D;
+      } else if (UserTypeMatches(name, "texturebuffer")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_BUFFER;
+      } else if (UserTypeMatches(name, "texturecube")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_CUBE;
+      } else if (UserTypeMatches(name, "texturecubearray")) {
+        p_target_decorations->user_type = SPV_REFLECT_USER_TYPE_TEXTURE_CUBE_ARRAY;
       }
-      break;
     }
   }
+
+  if (spec_constant_count > 0) {
+    p_module->spec_constants = (SpvReflectSpecializationConstant*)calloc(spec_constant_count, sizeof(*p_module->spec_constants));
+    if (IsNull(p_module->spec_constants)) {
+      return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+    }
+  }
+  for (uint32_t i = 0; i < p_parser->node_count; ++i) {
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
+    if (p_node->op == SpvOpDecorate) {
+      uint32_t decoration = (uint32_t)INVALID_VALUE;
+      CHECKED_READU32(p_parser, p_node->word_offset + 2, decoration);
+      if (decoration == SpvDecorationSpecId) {
+        const uint32_t count = p_module->spec_constant_count;
+        CHECKED_READU32(p_parser, p_node->word_offset + 1, p_module->spec_constants[count].spirv_id);
+        CHECKED_READU32(p_parser, p_node->word_offset + 3, p_module->spec_constants[count].constant_id);
+        // If being used for a OpSpecConstantComposite (ex. LocalSizeId), there won't be a name
+        SpvReflectPrvNode* target_node = FindNode(p_parser, p_module->spec_constants[count].spirv_id);
+        if (IsNotNull(target_node)) {
+          p_module->spec_constants[count].name = target_node->name;
+        }
+        p_module->spec_constant_count++;
+      }
+    }
+  }
+
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult EnumerateAllUniforms(
-  SpvReflectShaderModule* p_module,
-  size_t*                 p_uniform_count, 
-  uint32_t**              pp_uniforms
-)
-{
+static SpvReflectResult EnumerateAllUniforms(SpvReflectShaderModule* p_module, size_t* p_uniform_count, uint32_t** pp_uniforms) {
   *p_uniform_count = p_module->descriptor_binding_count;
   if (*p_uniform_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
@@ -1479,22 +1759,17 @@ static SpvReflectResult EnumerateAllUniforms(
   for (size_t i = 0; i < *p_uniform_count; ++i) {
     (*pp_uniforms)[i] = p_module->descriptor_bindings[i].spirv_id;
   }
-  qsort(*pp_uniforms, *p_uniform_count, sizeof(**pp_uniforms),
-        SortCompareUint32);
+  qsort(*pp_uniforms, *p_uniform_count, sizeof(**pp_uniforms), SortCompareUint32);
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseType(
-  Parser*                     p_parser, 
-  Node*                       p_node, 
-  Decorations*                p_struct_member_decorations, 
-  SpvReflectShaderModule*     p_module, 
-  SpvReflectTypeDescription*  p_type
-)
-{
+static SpvReflectResult ParseType(SpvReflectPrvParser* p_parser, SpvReflectPrvNode* p_node,
+                                  SpvReflectPrvDecorations* p_struct_member_decorations, SpvReflectShaderModule* p_module,
+                                  SpvReflectTypeDescription* p_type) {
   SpvReflectResult result = SPV_REFLECT_RESULT_SUCCESS;
 
   if (p_node->member_count > 0) {
+    p_type->struct_type_description = FindType(p_module, p_node->result_id);
     p_type->member_count = p_node->member_count;
     p_type->members = (SpvReflectTypeDescription*)calloc(p_type->member_count, sizeof(*(p_type->members)));
     if (IsNotNull(p_type->members)) {
@@ -1505,8 +1780,7 @@ static SpvReflectResult ParseType(
         p_member_type->op = (SpvOp)INVALID_VALUE;
         p_member_type->storage_class = (SpvStorageClass)INVALID_VALUE;
       }
-    }
-    else {
+    } else {
       result = SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
   }
@@ -1524,7 +1798,8 @@ static SpvReflectResult ParseType(
     p_type->decoration_flags = ApplyDecorations(&p_node->decorations);
 
     switch (p_node->op) {
-      default: break;
+      default:
+        break;
       case SpvOpTypeVoid:
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_VOID;
         break;
@@ -1537,14 +1812,12 @@ static SpvReflectResult ParseType(
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_INT;
         IF_READU32(result, p_parser, p_node->word_offset + 2, p_type->traits.numeric.scalar.width);
         IF_READU32(result, p_parser, p_node->word_offset + 3, p_type->traits.numeric.scalar.signedness);
-      }
-      break;
+      } break;
 
       case SpvOpTypeFloat: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_FLOAT;
         IF_READU32(result, p_parser, p_node->word_offset + 2, p_type->traits.numeric.scalar.width);
-      }
-      break;
+      } break;
 
       case SpvOpTypeVector: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_VECTOR;
@@ -1552,27 +1825,24 @@ static SpvReflectResult ParseType(
         IF_READU32(result, p_parser, p_node->word_offset + 2, component_type_id);
         IF_READU32(result, p_parser, p_node->word_offset + 3, p_type->traits.numeric.vector.component_count);
         // Parse component type
-        Node* p_next_node = FindNode(p_parser, component_type_id);
+        SpvReflectPrvNode* p_next_node = FindNode(p_parser, component_type_id);
         if (IsNotNull(p_next_node)) {
           result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
-        }
-        else {
+        } else {
           result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
           SPV_REFLECT_ASSERT(false);
         }
-      }
-      break;
+      } break;
 
       case SpvOpTypeMatrix: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_MATRIX;
         uint32_t column_type_id = (uint32_t)INVALID_VALUE;
         IF_READU32(result, p_parser, p_node->word_offset + 2, column_type_id);
         IF_READU32(result, p_parser, p_node->word_offset + 3, p_type->traits.numeric.matrix.column_count);
-        Node* p_next_node = FindNode(p_parser, column_type_id);
+        SpvReflectPrvNode* p_next_node = FindNode(p_parser, column_type_id);
         if (IsNotNull(p_next_node)) {
           result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
-        }
-        else {
+        } else {
           result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
           SPV_REFLECT_ASSERT(false);
         }
@@ -1582,18 +1852,16 @@ static SpvReflectResult ParseType(
         if (IsNotNull(p_struct_member_decorations)) {
           p_type->traits.numeric.matrix.stride = p_struct_member_decorations->matrix_stride;
         }
-      }
-      break;
+      } break;
 
       case SpvOpTypeImage: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE;
         uint32_t sampled_type_id = (uint32_t)INVALID_VALUE;
         IF_READU32(result, p_parser, p_node->word_offset + 2, sampled_type_id);
-        Node* p_next_node = FindNode(p_parser, sampled_type_id);
+        SpvReflectPrvNode* p_next_node = FindNode(p_parser, sampled_type_id);
         if (IsNotNull(p_next_node)) {
           result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
-        }
-        else {
+        } else {
           result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
         }
         IF_READU32_CAST(result, p_parser, p_node->word_offset + 3, SpvDim, p_type->traits.image.dim);
@@ -1602,28 +1870,24 @@ static SpvReflectResult ParseType(
         IF_READU32(result, p_parser, p_node->word_offset + 6, p_type->traits.image.ms);
         IF_READU32(result, p_parser, p_node->word_offset + 7, p_type->traits.image.sampled);
         IF_READU32_CAST(result, p_parser, p_node->word_offset + 8, SpvImageFormat, p_type->traits.image.image_format);
-      }
-      break;
+      } break;
 
       case SpvOpTypeSampler: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLER;
-      }
-      break;
+      } break;
 
       case SpvOpTypeSampledImage: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLED_IMAGE;
         uint32_t image_type_id = (uint32_t)INVALID_VALUE;
         IF_READU32(result, p_parser, p_node->word_offset + 2, image_type_id);
-        Node* p_next_node = FindNode(p_parser, image_type_id);
+        SpvReflectPrvNode* p_next_node = FindNode(p_parser, image_type_id);
         if (IsNotNull(p_next_node)) {
           result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
-        }
-        else {
-          result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;          
+        } else {
+          result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
           SPV_REFLECT_ASSERT(false);
         }
-      }
-      break;
+      } break;
 
       case SpvOpTypeArray: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_ARRAY;
@@ -1636,53 +1900,50 @@ static SpvReflectResult ParseType(
           //       OpMemberDecorate, even if the array is apart of a struct.
           p_type->traits.array.stride = p_node->decorations.array_stride;
           // Get length for current dimension
-          Node* p_length_node = FindNode(p_parser, length_id);
+          SpvReflectPrvNode* p_length_node = FindNode(p_parser, length_id);
           if (IsNotNull(p_length_node)) {
-            if (p_length_node->op == SpvOpSpecConstant ||
-                p_length_node->op == SpvOpSpecConstantOp) {
-              p_type->traits.array.dims[p_type->traits.array.dims_count] = 0xFFFFFFFF;
+            uint32_t dim_index = p_type->traits.array.dims_count;
+            uint32_t length = 0;
+            IF_READU32(result, p_parser, p_length_node->word_offset + 3, length);
+            if (result == SPV_REFLECT_RESULT_SUCCESS) {
+              p_type->traits.array.dims[dim_index] = length;
               p_type->traits.array.dims_count += 1;
+              p_type->traits.array.spec_constant_op_ids[dim_index] =
+                  IsSpecConstant(p_length_node) ? p_length_node->decorations.spec_id : (uint32_t)INVALID_VALUE;
             } else {
-              uint32_t length = 0;
-              IF_READU32(result, p_parser, p_length_node->word_offset + 3, length);
-              if (result == SPV_REFLECT_RESULT_SUCCESS) {
-                // Write the array dim and increment the count and offset
-                p_type->traits.array.dims[p_type->traits.array.dims_count] = length;
-                p_type->traits.array.dims_count += 1;
-              } else {
-                result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
-                SPV_REFLECT_ASSERT(false);
-              }
+              result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+              SPV_REFLECT_ASSERT(false);
             }
             // Parse next dimension or element type
-            Node* p_next_node = FindNode(p_parser, element_type_id);
+            SpvReflectPrvNode* p_next_node = FindNode(p_parser, element_type_id);
             if (IsNotNull(p_next_node)) {
               result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
             }
-          }
-          else {
+          } else {
             result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
             SPV_REFLECT_ASSERT(false);
           }
         }
-      }
-      break;
+      } break;
 
       case SpvOpTypeRuntimeArray: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_ARRAY;
         uint32_t element_type_id = (uint32_t)INVALID_VALUE;
         IF_READU32(result, p_parser, p_node->word_offset + 2, element_type_id);
+        p_type->traits.array.stride = p_node->decorations.array_stride;
+        uint32_t dim_index = p_type->traits.array.dims_count;
+        p_type->traits.array.dims[dim_index] = (uint32_t)SPV_REFLECT_ARRAY_DIM_RUNTIME;
+        p_type->traits.array.spec_constant_op_ids[dim_index] = (uint32_t)INVALID_VALUE;
+        p_type->traits.array.dims_count += 1;
         // Parse next dimension or element type
-        Node* p_next_node = FindNode(p_parser, element_type_id);
+        SpvReflectPrvNode* p_next_node = FindNode(p_parser, element_type_id);
         if (IsNotNull(p_next_node)) {
           result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
-        }
-        else {
+        } else {
           result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
           SPV_REFLECT_ASSERT(false);
         }
-      }
-      break;
+      } break;
 
       case SpvOpTypeStruct: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_STRUCT;
@@ -1693,7 +1954,7 @@ static SpvReflectResult ParseType(
           uint32_t member_id = (uint32_t)INVALID_VALUE;
           IF_READU32(result, p_parser, p_node->word_offset + word_index, member_id);
           // Find member node
-          Node* p_member_node = FindNode(p_parser, member_id);
+          SpvReflectPrvNode* p_member_node = FindNode(p_parser, member_id);
           if (IsNull(p_member_node)) {
             result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
             SPV_REFLECT_ASSERT(false);
@@ -1701,7 +1962,7 @@ static SpvReflectResult ParseType(
           }
 
           // Member decorations
-          Decorations* p_member_decorations = &p_node->member_decorations[member_index];
+          SpvReflectPrvDecorations* p_member_decorations = &p_node->member_decorations[member_index];
 
           assert(member_index < p_type->member_count);
           // Parse member type
@@ -1712,35 +1973,57 @@ static SpvReflectResult ParseType(
           if (result != SPV_REFLECT_RESULT_SUCCESS) {
             break;
           }
-          // This looks wrong 
-          //p_member_type->type_name = p_member_node->name;
+          // This looks wrong
+          // p_member_type->type_name = p_member_node->name;
           p_member_type->struct_member_name = p_node->member_names[member_index];
         }
-      }
-      break;
+      } break;
 
-      case SpvOpTypeOpaque: break;
+      case SpvOpTypeOpaque:
+        break;
 
       case SpvOpTypePointer: {
+        p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_REF;
         IF_READU32_CAST(result, p_parser, p_node->word_offset + 2, SpvStorageClass, p_type->storage_class);
-        uint32_t type_id = (uint32_t)INVALID_VALUE;
-        IF_READU32(result, p_parser, p_node->word_offset + 3, type_id);
-        // Parse type
-        Node* p_next_node = FindNode(p_parser, type_id);
-        if (IsNotNull(p_next_node)) {
-          result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
+
+        bool found_recursion = false;
+        if (p_type->storage_class == SpvStorageClassPhysicalStorageBuffer) {
+          // Need to make sure we haven't started an infinite recursive loop
+          for (uint32_t i = 0; i < p_parser->physical_pointer_count; i++) {
+            if (p_type->id == p_parser->physical_pointer_check[i]->id) {
+              found_recursion = true;
+              memcpy(p_type, p_parser->physical_pointer_check[i], sizeof(SpvReflectTypeDescription));
+              p_type->copied = 1;
+              return SPV_REFLECT_RESULT_SUCCESS;
+            }
+          }
+          if (!found_recursion) {
+            p_parser->physical_pointer_struct_count++;
+            p_parser->physical_pointer_check[p_parser->physical_pointer_count] = p_type;
+            p_parser->physical_pointer_count++;
+            if (p_parser->physical_pointer_count >= MAX_RECURSIVE_PHYSICAL_POINTER_CHECK) {
+              return SPV_REFLECT_RESULT_ERROR_SPIRV_MAX_RECURSIVE_EXCEEDED;
+            }
+          }
         }
-        else {
+
+        // Parse type
+        SpvReflectPrvNode* p_next_node = FindNode(p_parser, p_node->type_id);
+        if (IsNull(p_next_node)) {
           result = SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
           SPV_REFLECT_ASSERT(false);
+        } else if (!found_recursion) {
+          if (p_next_node->op == SpvOpTypeStruct) {
+            p_type->struct_type_description = FindType(p_module, p_next_node->result_id);
+          }
+
+          result = ParseType(p_parser, p_next_node, NULL, p_module, p_type);
         }
-      }
-      break;
+      } break;
 
       case SpvOpTypeAccelerationStructureKHR: {
         p_type->type_flags |= SPV_REFLECT_TYPE_FLAG_EXTERNAL_ACCELERATION_STRUCTURE;
-      }
-      break;
+      } break;
     }
 
     if (result == SPV_REFLECT_RESULT_SUCCESS) {
@@ -1755,8 +2038,7 @@ static SpvReflectResult ParseType(
   return result;
 }
 
-static SpvReflectResult ParseTypes(Parser* p_parser, SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseTypes(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
   if (p_parser->type_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
   }
@@ -1778,23 +2060,66 @@ static SpvReflectResult ParseTypes(Parser* p_parser, SpvReflectShaderModule* p_m
 
   size_t type_index = 0;
   for (size_t i = 0; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
-    if (! p_node->is_type) {
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
+    if (!p_node->is_type) {
       continue;
     }
 
     SpvReflectTypeDescription* p_type = &(p_module->_internal->type_descriptions[type_index]);
+    p_parser->physical_pointer_count = 0;
     SpvReflectResult result = ParseType(p_parser, p_node, NULL, p_module, p_type);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
     ++type_index;
   }
+
+  // allocate now and fill in when parsing struct variable later
+  if (p_parser->physical_pointer_struct_count > 0) {
+    p_parser->physical_pointer_structs = (SpvReflectPrvPhysicalPointerStruct*)calloc(p_parser->physical_pointer_struct_count,
+                                                                                     sizeof(*(p_parser->physical_pointer_structs)));
+    if (IsNull(p_parser->physical_pointer_structs)) {
+      return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+    }
+  }
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static int SortCompareDescriptorBinding(const void* a, const void* b)
-{
+static SpvReflectResult ParseCapabilities(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
+  if (p_parser->capability_count == 0) {
+    return SPV_REFLECT_RESULT_SUCCESS;
+  }
+
+  p_module->capability_count = p_parser->capability_count;
+  p_module->capabilities = (SpvReflectCapability*)calloc(p_module->capability_count, sizeof(*(p_module->capabilities)));
+  if (IsNull(p_module->capabilities)) {
+    return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+  }
+
+  // Mark all types with an invalid state
+  for (size_t i = 0; i < p_module->capability_count; ++i) {
+    SpvReflectCapability* p_cap = &(p_module->capabilities[i]);
+    p_cap->value = SpvCapabilityMax;
+    p_cap->word_offset = (uint32_t)INVALID_VALUE;
+  }
+
+  size_t capability_index = 0;
+  for (size_t i = 0; i < p_parser->node_count; ++i) {
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
+    if (SpvOpCapability != p_node->op) {
+      continue;
+    }
+
+    SpvReflectCapability* p_cap = &(p_module->capabilities[capability_index]);
+    p_cap->value = p_node->capability;
+    p_cap->word_offset = p_node->word_offset + 1;
+    ++capability_index;
+  }
+
+  return SPV_REFLECT_RESULT_SUCCESS;
+}
+
+static int SortCompareDescriptorBinding(const void* a, const void* b) {
   const SpvReflectDescriptorBinding* p_elem_a = (const SpvReflectDescriptorBinding*)a;
   const SpvReflectDescriptorBinding* p_elem_b = (const SpvReflectDescriptorBinding*)b;
   int value = (int)(p_elem_a->binding) - (int)(p_elem_b->binding);
@@ -1807,16 +2132,13 @@ static int SortCompareDescriptorBinding(const void* a, const void* b)
   return value;
 }
 
-static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseDescriptorBindings(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
   p_module->descriptor_binding_count = 0;
   for (size_t i = 0; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
     if ((p_node->op != SpvOpVariable) ||
-        ((p_node->storage_class != SpvStorageClassUniform) &&
-         (p_node->storage_class != SpvStorageClassStorageBuffer) &&
-         (p_node->storage_class != SpvStorageClassUniformConstant)))
-    {
+        ((p_node->storage_class != SpvStorageClassUniform) && (p_node->storage_class != SpvStorageClassStorageBuffer) &&
+         (p_node->storage_class != SpvStorageClassUniformConstant))) {
       continue;
     }
     if ((p_node->decorations.set.value == INVALID_VALUE) || (p_node->decorations.binding.value == INVALID_VALUE)) {
@@ -1830,7 +2152,8 @@ static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShad
     return SPV_REFLECT_RESULT_SUCCESS;
   }
 
-  p_module->descriptor_bindings = (SpvReflectDescriptorBinding*)calloc(p_module->descriptor_binding_count, sizeof(*(p_module->descriptor_bindings)));
+  p_module->descriptor_bindings =
+      (SpvReflectDescriptorBinding*)calloc(p_module->descriptor_binding_count, sizeof(*(p_module->descriptor_bindings)));
   if (IsNull(p_module->descriptor_bindings)) {
     return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
   }
@@ -1847,12 +2170,10 @@ static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShad
 
   size_t descriptor_index = 0;
   for (size_t i = 0; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
     if ((p_node->op != SpvOpVariable) ||
-        ((p_node->storage_class != SpvStorageClassUniform) &&
-         (p_node->storage_class != SpvStorageClassStorageBuffer) &&
-         (p_node->storage_class != SpvStorageClassUniformConstant)))
-    {
+        ((p_node->storage_class != SpvStorageClassUniform) && (p_node->storage_class != SpvStorageClassStorageBuffer) &&
+         (p_node->storage_class != SpvStorageClassUniformConstant))) {
       continue;
     }
     if ((p_node->decorations.set.value == INVALID_VALUE) || (p_node->decorations.binding.value == INVALID_VALUE)) {
@@ -1869,7 +2190,7 @@ static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShad
     if (p_type->op == SpvOpTypePointer) {
       pointer_storage_class = p_type->storage_class;
       // Find the type's node
-      Node* p_type_node = FindNode(p_parser, p_type->id);
+      SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
       if (IsNull(p_type_node)) {
         return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
       }
@@ -1889,6 +2210,36 @@ static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShad
     p_descriptor->count = 1;
     p_descriptor->uav_counter_id = p_node->decorations.uav_counter_buffer.value;
     p_descriptor->type_description = p_type;
+    p_descriptor->decoration_flags = ApplyDecorations(&p_node->decorations);
+    p_descriptor->user_type = p_node->decorations.user_type;
+
+    // Flags like non-writable and non-readable are found as member decorations only.
+    // If all members have one of those decorations set, promote the decoration up
+    // to the whole descriptor.
+    const SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
+    if (IsNotNull(p_type_node) && p_type_node->member_count) {
+      SpvReflectPrvDecorations common_flags = p_type_node->member_decorations[0];
+
+      for (uint32_t m = 1; m < p_type_node->member_count; ++m) {
+        common_flags.is_relaxed_precision &= p_type_node->member_decorations[m].is_relaxed_precision;
+        common_flags.is_block &= p_type_node->member_decorations[m].is_block;
+        common_flags.is_buffer_block &= p_type_node->member_decorations[m].is_buffer_block;
+        common_flags.is_row_major &= p_type_node->member_decorations[m].is_row_major;
+        common_flags.is_column_major &= p_type_node->member_decorations[m].is_column_major;
+        common_flags.is_built_in &= p_type_node->member_decorations[m].is_built_in;
+        common_flags.is_noperspective &= p_type_node->member_decorations[m].is_noperspective;
+        common_flags.is_flat &= p_type_node->member_decorations[m].is_flat;
+        common_flags.is_non_writable &= p_type_node->member_decorations[m].is_non_writable;
+        common_flags.is_non_readable &= p_type_node->member_decorations[m].is_non_readable;
+        common_flags.is_patch &= p_type_node->member_decorations[m].is_patch;
+        common_flags.is_per_vertex &= p_type_node->member_decorations[m].is_per_vertex;
+        common_flags.is_per_task &= p_type_node->member_decorations[m].is_per_task;
+        common_flags.is_weight_texture &= p_type_node->member_decorations[m].is_weight_texture;
+        common_flags.is_block_match_texture &= p_type_node->member_decorations[m].is_block_match_texture;
+      }
+
+      p_descriptor->decoration_flags |= ApplyDecorations(&common_flags);
+    }
 
     // If this is in the StorageBuffer storage class, it's for sure a storage
     // buffer descriptor. We need to handle this case earlier because in SPIR-V
@@ -1927,7 +2278,6 @@ static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShad
 
     // Count
 
-
     p_descriptor->word_offset.binding = p_node->decorations.binding.word_offset;
     p_descriptor->word_offset.set = p_node->decorations.set.word_offset;
 
@@ -1935,17 +2285,14 @@ static SpvReflectResult ParseDescriptorBindings(Parser* p_parser, SpvReflectShad
   }
 
   if (p_module->descriptor_binding_count > 0) {
-    qsort(p_module->descriptor_bindings,
-          p_module->descriptor_binding_count,
-          sizeof(*(p_module->descriptor_bindings)),
+    qsort(p_module->descriptor_bindings, p_module->descriptor_binding_count, sizeof(*(p_module->descriptor_bindings)),
           SortCompareDescriptorBinding);
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseDescriptorType(SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseDescriptorType(SpvReflectShaderModule* p_module) {
   if (p_module->descriptor_binding_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
   }
@@ -1956,90 +2303,122 @@ static SpvReflectResult ParseDescriptorType(SpvReflectShaderModule* p_module)
 
     if ((int)p_descriptor->descriptor_type == (int)INVALID_VALUE) {
       switch (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_EXTERNAL_MASK) {
-        default: assert(false && "unknown type flag"); break;
+        default:
+          assert(false && "unknown type flag");
+          break;
 
         case SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE: {
           if (p_descriptor->image.dim == SpvDimBuffer) {
             switch (p_descriptor->image.sampled) {
-              default: assert(false && "unknown texel buffer sampled value"); break;
-              case IMAGE_SAMPLED: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; break;
-              case IMAGE_STORAGE: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; break;
+              default:
+                assert(false && "unknown texel buffer sampled value");
+                break;
+              case IMAGE_SAMPLED:
+                p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
+                break;
+              case IMAGE_STORAGE:
+                p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+                break;
             }
-          }
-          else if(p_descriptor->image.dim == SpvDimSubpassData) {
+          } else if (p_descriptor->image.dim == SpvDimSubpassData) {
             p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-          }
-          else {
+          } else {
             switch (p_descriptor->image.sampled) {
-              default: assert(false && "unknown image sampled value"); break;
-              case IMAGE_SAMPLED: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE; break;
-              case IMAGE_STORAGE: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE; break;
+              default:
+                assert(false && "unknown image sampled value");
+                break;
+              case IMAGE_SAMPLED:
+                p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+                break;
+              case IMAGE_STORAGE:
+                p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+                break;
             }
           }
-        }
-        break;
+        } break;
 
         case SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLER: {
           p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLER;
-        }
-        break;
+        } break;
 
         case (SPV_REFLECT_TYPE_FLAG_EXTERNAL_SAMPLED_IMAGE | SPV_REFLECT_TYPE_FLAG_EXTERNAL_IMAGE): {
           // This is a workaround for: https://github.com/KhronosGroup/glslang/issues/1096
           if (p_descriptor->image.dim == SpvDimBuffer) {
             switch (p_descriptor->image.sampled) {
-              default: assert(false && "unknown texel buffer sampled value"); break;
-              case IMAGE_SAMPLED: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; break;
-              case IMAGE_STORAGE: p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; break;
+              default:
+                assert(false && "unknown texel buffer sampled value");
+                break;
+              case IMAGE_SAMPLED:
+                p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
+                break;
+              case IMAGE_STORAGE:
+                p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+                break;
             }
-          }
-          else {
+          } else {
             p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
           }
-        }
-        break;
+        } break;
 
         case SPV_REFLECT_TYPE_FLAG_EXTERNAL_BLOCK: {
           if (p_type->decoration_flags & SPV_REFLECT_DECORATION_BLOCK) {
             p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-          }
-          else if (p_type->decoration_flags & SPV_REFLECT_DECORATION_BUFFER_BLOCK) {
+          } else if (p_type->decoration_flags & SPV_REFLECT_DECORATION_BUFFER_BLOCK) {
             p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-          }
-          else {
+          } else {
             assert(false && "unknown struct");
           }
-        }
-        break;
+        } break;
 
         case SPV_REFLECT_TYPE_FLAG_EXTERNAL_ACCELERATION_STRUCTURE: {
           p_descriptor->descriptor_type = SPV_REFLECT_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
-        }
-        break;
+        } break;
       }
     }
 
     switch (p_descriptor->descriptor_type) {
-      case SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLER                    : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SAMPLER; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER     : p_descriptor->resource_type = (SpvReflectResourceType)(SPV_REFLECT_RESOURCE_FLAG_SAMPLER | SPV_REFLECT_RESOURCE_FLAG_SRV); break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE              : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE              : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER       : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER       : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER             : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_CBV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC     : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_CBV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER             : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC     : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV; break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_INPUT_ATTACHMENT           : break;
-      case SPV_REFLECT_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR : p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV; break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLER:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SAMPLER;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+        p_descriptor->resource_type = (SpvReflectResourceType)(SPV_REFLECT_RESOURCE_FLAG_SAMPLER | SPV_REFLECT_RESOURCE_FLAG_SRV);
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_CBV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_CBV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_UAV;
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+        break;
+      case SPV_REFLECT_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+        p_descriptor->resource_type = SPV_REFLECT_RESOURCE_FLAG_SRV;
+        break;
     }
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseUAVCounterBindings(SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseUAVCounterBindings(SpvReflectShaderModule* p_module) {
   char name[MAX_NODE_NAME_LENGTH];
   const char* k_count_tag = "@count";
 
@@ -2053,7 +2432,8 @@ static SpvReflectResult ParseUAVCounterBindings(SpvReflectShaderModule* p_module
     SpvReflectDescriptorBinding* p_counter_descriptor = NULL;
     // Use UAV counter buffer id if present...
     if (p_descriptor->uav_counter_id != UINT32_MAX) {
-      for (uint32_t counter_descriptor_index = 0; counter_descriptor_index < p_module->descriptor_binding_count; ++counter_descriptor_index) {
+      for (uint32_t counter_descriptor_index = 0; counter_descriptor_index < p_module->descriptor_binding_count;
+           ++counter_descriptor_index) {
         SpvReflectDescriptorBinding* p_test_counter_descriptor = &(p_module->descriptor_bindings[counter_descriptor_index]);
         if (p_test_counter_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
           continue;
@@ -2066,9 +2446,9 @@ static SpvReflectResult ParseUAVCounterBindings(SpvReflectShaderModule* p_module
     }
     // ...otherwise use old @count convention.
     else {
-      const size_t descriptor_name_length = p_descriptor->name? strlen(p_descriptor->name): 0;
+      const size_t descriptor_name_length = p_descriptor->name ? strlen(p_descriptor->name) : 0;
 
-      memset(name, 0, MAX_NODE_NAME_LENGTH);    
+      memset(name, 0, MAX_NODE_NAME_LENGTH);
       memcpy(name, p_descriptor->name, descriptor_name_length);
 #if defined(_WIN32)
       strcat_s(name, MAX_NODE_NAME_LENGTH, k_count_tag);
@@ -2076,7 +2456,8 @@ static SpvReflectResult ParseUAVCounterBindings(SpvReflectShaderModule* p_module
       strcat(name, k_count_tag);
 #endif
 
-      for (uint32_t counter_descriptor_index = 0; counter_descriptor_index < p_module->descriptor_binding_count; ++counter_descriptor_index) {
+      for (uint32_t counter_descriptor_index = 0; counter_descriptor_index < p_module->descriptor_binding_count;
+           ++counter_descriptor_index) {
         SpvReflectDescriptorBinding* p_test_counter_descriptor = &(p_module->descriptor_bindings[counter_descriptor_index]);
         if (p_test_counter_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
           continue;
@@ -2096,13 +2477,8 @@ static SpvReflectResult ParseUAVCounterBindings(SpvReflectShaderModule* p_module
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseDescriptorBlockVariable(
-  Parser*                     p_parser, 
-  SpvReflectShaderModule*     p_module, 
-  SpvReflectTypeDescription*  p_type, 
-  SpvReflectBlockVariable*    p_var
-)
-{
+static SpvReflectResult ParseDescriptorBlockVariable(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module,
+                                                     SpvReflectTypeDescription* p_type, SpvReflectBlockVariable* p_var) {
   bool has_non_writable = false;
 
   if (IsNotNull(p_type->members) && (p_type->member_count > 0)) {
@@ -2112,44 +2488,110 @@ static SpvReflectResult ParseDescriptorBlockVariable(
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
 
-    Node* p_type_node = FindNode(p_parser, p_type->id);
+    SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
     if (IsNull(p_type_node)) {
       return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
     }
     // Resolve to element type if current type is array or run time array
-    if (p_type_node->op == SpvOpTypeArray) {
-      while (p_type_node->op == SpvOpTypeArray) {
+    while (p_type_node->op == SpvOpTypeArray || p_type_node->op == SpvOpTypeRuntimeArray) {
+      if (p_type_node->op == SpvOpTypeArray) {
         p_type_node = FindNode(p_parser, p_type_node->array_traits.element_type_id);
-        if (IsNull(p_type_node)) {
+      } else {
+        // Element type description
+        SpvReflectTypeDescription* p_type_temp = FindType(p_module, p_type_node->array_traits.element_type_id);
+        if (IsNull(p_type_temp)) {
           return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
         }
+        // Element type node
+        p_type_node = FindNode(p_parser, p_type_temp->id);
       }
-    }
-    else if(p_type_node->op == SpvOpTypeRuntimeArray) {
-      // Element type description
-      p_type = FindType(p_module, p_type_node->array_traits.element_type_id);
-      if (IsNull(p_type)) {
-        return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
-      }
-      // Element type node
-      p_type_node = FindNode(p_parser, p_type->id);
       if (IsNull(p_type_node)) {
         return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
       }
     }
-    
+
     // Parse members
     for (uint32_t member_index = 0; member_index < p_type->member_count; ++member_index) {
       SpvReflectTypeDescription* p_member_type = &p_type->members[member_index];
       SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
+      // If pointer type, treat like reference and resolve to pointee type
+      SpvReflectTypeDescription* p_member_ptr_type = 0;
+      bool found_recursion = false;
+
+      if ((p_member_type->storage_class == SpvStorageClassPhysicalStorageBuffer) &&
+          (p_member_type->type_flags & SPV_REFLECT_TYPE_FLAG_REF)) {
+        // Remember the original type
+        p_member_ptr_type = p_member_type;
+
+        // strip array
+        if (p_member_type->op == SpvOpTypeArray || p_member_type->op == SpvOpTypeRuntimeArray) {
+          SpvReflectPrvNode* p_node = FindNode(p_parser, p_member_type->id);
+          if (p_node == NULL) {
+            return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+          }
+          uint32_t element_type_id = p_node->array_traits.element_type_id;
+          p_member_type = FindType(p_module, element_type_id);
+          if (p_member_type == NULL) {
+            return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+          }
+        }
+
+        // Need to make sure we haven't started an infinite recursive loop
+        for (uint32_t i = 0; i < p_parser->physical_pointer_count; i++) {
+          if (p_member_type->id == p_parser->physical_pointer_check[i]->id) {
+            found_recursion = true;
+            break;  // still need to fill in p_member_type values
+          }
+        }
+        if (!found_recursion) {
+          uint32_t struct_id = FindType(p_module, p_member_type->id)->struct_type_description->id;
+          p_parser->physical_pointer_structs[p_parser->physical_pointer_struct_count].struct_id = struct_id;
+          p_parser->physical_pointer_structs[p_parser->physical_pointer_struct_count].p_var = p_member_var;
+          p_parser->physical_pointer_struct_count++;
+
+          p_parser->physical_pointer_check[p_parser->physical_pointer_count] = p_member_type;
+          p_parser->physical_pointer_count++;
+          if (p_parser->physical_pointer_count >= MAX_RECURSIVE_PHYSICAL_POINTER_CHECK) {
+            return SPV_REFLECT_RESULT_ERROR_SPIRV_MAX_RECURSIVE_EXCEEDED;
+          }
+        }
+
+        SpvReflectPrvNode* p_member_type_node = FindNode(p_parser, p_member_type->id);
+        if (IsNull(p_member_type_node)) {
+          return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+        }
+        // Should be the pointee type
+        p_member_type = FindType(p_module, p_member_type_node->type_id);
+        if (IsNull(p_member_type)) {
+          return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+        }
+      }
       bool is_struct = (p_member_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) == SPV_REFLECT_TYPE_FLAG_STRUCT;
       if (is_struct) {
-        SpvReflectResult result = ParseDescriptorBlockVariable(p_parser, p_module, p_member_type, p_member_var);
-        if (result != SPV_REFLECT_RESULT_SUCCESS) {
-          return result;
+        if (!found_recursion) {
+          SpvReflectResult result = ParseDescriptorBlockVariable(p_parser, p_module, p_member_type, p_member_var);
+          if (result != SPV_REFLECT_RESULT_SUCCESS) {
+            return result;
+          }
+        } else {
+          // if 2 member of structs are same PhysicalPointer type, copy the
+          // members values that aren't found skipping the recursion call
+          for (uint32_t i = 0; i < p_parser->physical_pointer_struct_count; i++) {
+            if (p_parser->physical_pointer_structs[i].struct_id == p_member_type->id) {
+              p_member_var->members = p_parser->physical_pointer_structs[i].p_var->members;
+              p_member_var->member_count = p_parser->physical_pointer_structs[i].p_var->member_count;
+              // Set here as it is the first time we need to walk down structs
+              p_member_var->flags |= SPV_REFLECT_VARIABLE_FLAGS_PHYSICAL_POINTER_COPY;
+            }
+          }
         }
       }
 
+      if (p_type_node->storage_class == SpvStorageClassPhysicalStorageBuffer && !p_type_node->member_names) {
+        // TODO 212 - If a buffer ref has an array of itself, all members are null
+        continue;
+      }
+
       p_member_var->name = p_type_node->member_names[member_index];
       p_member_var->offset = p_type_node->member_decorations[member_index].offset.value;
       p_member_var->decoration_flags = ApplyDecorations(&p_type_node->member_decorations[member_index]);
@@ -2162,7 +2604,8 @@ static SpvReflectResult ParseDescriptorBlockVariable(
         ApplyArrayTraits(p_member_type, &p_member_var->array);
       }
 
-      p_member_var->type_description = p_member_type;
+      p_member_var->word_offset.offset = p_type_node->member_decorations[member_index].offset.word_offset;
+      p_member_var->type_description = p_member_ptr_type ? p_member_ptr_type : p_member_type;
     }
   }
 
@@ -2175,27 +2618,32 @@ static SpvReflectResult ParseDescriptorBlockVariable(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseDescriptorBlockVariableSizes(
-  Parser*                   p_parser, 
-  SpvReflectShaderModule*   p_module, 
-  bool                      is_parent_root, 
-  bool                      is_parent_aos, 
-  bool                      is_parent_rta, 
-  SpvReflectBlockVariable*  p_var
-)
-{
+static uint32_t GetPhysicalPointerStructSize(SpvReflectPrvParser* p_parser, uint32_t id) {
+  for (uint32_t i = 0; i < p_parser->physical_pointer_struct_count; i++) {
+    if (p_parser->physical_pointer_structs[i].struct_id == id) {
+      return p_parser->physical_pointer_structs[i].p_var->size;
+    }
+  }
+  return 0;
+}
+
+static SpvReflectResult ParseDescriptorBlockVariableSizes(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module,
+                                                          bool is_parent_root, bool is_parent_aos, bool is_parent_rta,
+                                                          SpvReflectBlockVariable* p_var) {
   if (p_var->member_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
   }
 
+  bool is_parent_ref = p_var->type_description->op == SpvOpTypePointer;
+
   // Absolute offsets
   for (uint32_t member_index = 0; member_index < p_var->member_count; ++member_index) {
     SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
     if (is_parent_root) {
       p_member_var->absolute_offset = p_member_var->offset;
-    }
-    else {
-      p_member_var->absolute_offset = is_parent_aos ? 0 : p_member_var->offset + p_var->absolute_offset;
+    } else {
+      p_member_var->absolute_offset =
+          is_parent_aos ? 0 : (is_parent_ref ? p_member_var->offset : p_member_var->offset + p_var->absolute_offset);
     }
   }
 
@@ -2204,42 +2652,46 @@ static SpvReflectResult ParseDescriptorBlockVariableSizes(
     SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
     SpvReflectTypeDescription* p_member_type = p_member_var->type_description;
 
+    if (!p_member_type) {
+      // TODO 212 - If a buffer ref has an array of itself, all members are null
+      continue;
+    }
     switch (p_member_type->op) {
       case SpvOpTypeBool: {
         p_member_var->size = SPIRV_WORD_SIZE;
-      }
-      break;
+      } break;
 
       case SpvOpTypeInt:
       case SpvOpTypeFloat: {
         p_member_var->size = p_member_type->traits.numeric.scalar.width / SPIRV_BYTE_WIDTH;
-      }
-      break;
+      } break;
 
       case SpvOpTypeVector: {
-        uint32_t size = p_member_type->traits.numeric.vector.component_count *
-                        (p_member_type->traits.numeric.scalar.width / SPIRV_BYTE_WIDTH);
+        uint32_t size =
+            p_member_type->traits.numeric.vector.component_count * (p_member_type->traits.numeric.scalar.width / SPIRV_BYTE_WIDTH);
         p_member_var->size = size;
-      }
-      break;
+      } break;
 
       case SpvOpTypeMatrix: {
         if (p_member_var->decoration_flags & SPV_REFLECT_DECORATION_COLUMN_MAJOR) {
           p_member_var->size = p_member_var->numeric.matrix.column_count * p_member_var->numeric.matrix.stride;
-        }
-        else if (p_member_var->decoration_flags & SPV_REFLECT_DECORATION_ROW_MAJOR) {
+        } else if (p_member_var->decoration_flags & SPV_REFLECT_DECORATION_ROW_MAJOR) {
           p_member_var->size = p_member_var->numeric.matrix.row_count * p_member_var->numeric.matrix.stride;
         }
-      }
-      break;
+      } break;
 
       case SpvOpTypeArray: {
         // If array of structs, parse members first...
         bool is_struct = (p_member_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) == SPV_REFLECT_TYPE_FLAG_STRUCT;
         if (is_struct) {
-          SpvReflectResult result = ParseDescriptorBlockVariableSizes(p_parser, p_module, false, true, is_parent_rta, p_member_var);
-          if (result != SPV_REFLECT_RESULT_SUCCESS) {
-            return result;
+          if (p_member_var->flags & SPV_REFLECT_VARIABLE_FLAGS_PHYSICAL_POINTER_COPY) {
+            p_member_var->size = GetPhysicalPointerStructSize(p_parser, p_member_type->id);
+          } else {
+            SpvReflectResult result =
+                ParseDescriptorBlockVariableSizes(p_parser, p_module, false, true, is_parent_rta, p_member_var);
+            if (result != SPV_REFLECT_RESULT_SUCCESS) {
+              return result;
+            }
           }
         }
         // ...then array
@@ -2248,8 +2700,7 @@ static SpvReflectResult ParseDescriptorBlockVariableSizes(
           element_count *= p_member_var->array.dims[i];
         }
         p_member_var->size = element_count * p_member_var->array.stride;
-      }
-      break;
+      } break;
 
       case SpvOpTypeRuntimeArray: {
         bool is_struct = (p_member_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) == SPV_REFLECT_TYPE_FLAG_STRUCT;
@@ -2259,26 +2710,69 @@ static SpvReflectResult ParseDescriptorBlockVariableSizes(
             return result;
           }
         }
+      } break;
+
+      case SpvOpTypePointer: {
+        // Reference. Get to underlying struct type.
+        SpvReflectPrvNode* p_member_type_node = FindNode(p_parser, p_member_type->id);
+        if (IsNull(p_member_type_node)) {
+          return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+        }
+        // Get the pointee type
+        p_member_type = FindType(p_module, p_member_type_node->type_id);
+        if (IsNull(p_member_type)) {
+          return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+        }
+        assert(p_member_type->op == SpvOpTypeStruct);
+        FALLTHROUGH;
       }
-      break;
 
       case SpvOpTypeStruct: {
-        SpvReflectResult result = ParseDescriptorBlockVariableSizes(p_parser, p_module, false, is_parent_aos, is_parent_rta, p_member_var);
-        if (result != SPV_REFLECT_RESULT_SUCCESS) {
-          return result;
+        if (p_member_var->flags & SPV_REFLECT_VARIABLE_FLAGS_PHYSICAL_POINTER_COPY) {
+          p_member_var->size = GetPhysicalPointerStructSize(p_parser, p_member_type->id);
+        } else {
+          SpvReflectResult result =
+              ParseDescriptorBlockVariableSizes(p_parser, p_module, false, is_parent_aos, is_parent_rta, p_member_var);
+          if (result != SPV_REFLECT_RESULT_SUCCESS) {
+            return result;
+          }
         }
-      }
-      break;
+      } break;
 
       default:
         break;
     }
   }
 
+  // Structs can offset order don't need to match the index order, so first order by offset
+  // example:
+  //     OpMemberDecorate %struct 0 Offset 4
+  //     OpMemberDecorate %struct 1 Offset 0
+  SpvReflectBlockVariable** pp_member_offset_order =
+      (SpvReflectBlockVariable**)calloc(p_var->member_count, sizeof(SpvReflectBlockVariable*));
+  if (IsNull(pp_member_offset_order)) {
+    return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+  }
+
+  uint32_t bottom_bound = 0;
+  for (uint32_t i = 0; i < p_var->member_count; ++i) {
+    uint32_t lowest_offset = UINT32_MAX;
+    uint32_t member_index = 0;
+    for (uint32_t j = 0; j < p_var->member_count; ++j) {
+      const uint32_t offset = p_var->members[j].offset;
+      if (offset < lowest_offset && offset >= bottom_bound) {
+        member_index = j;
+        lowest_offset = offset;
+      }
+    }
+    pp_member_offset_order[i] = &p_var->members[member_index];
+    bottom_bound = lowest_offset + 1;  // 2 index can't share the same offset
+  }
+
   // Parse padded size using offset difference for all member except for the last entry...
-  for (uint32_t member_index = 0; member_index < (p_var->member_count - 1); ++member_index) {
-    SpvReflectBlockVariable* p_member_var = &p_var->members[member_index];
-    SpvReflectBlockVariable* p_next_member_var = &p_var->members[member_index + 1];
+  for (uint32_t i = 0; i < (p_var->member_count - 1); ++i) {
+    SpvReflectBlockVariable* p_member_var = pp_member_offset_order[i];
+    SpvReflectBlockVariable* p_next_member_var = pp_member_offset_order[i + 1];
     p_member_var->padded_size = p_next_member_var->offset - p_member_var->offset;
     if (p_member_var->size > p_member_var->padded_size) {
       p_member_var->size = p_member_var->padded_size;
@@ -2287,82 +2781,79 @@ static SpvReflectResult ParseDescriptorBlockVariableSizes(
       p_member_var->padded_size = p_member_var->size;
     }
   }
+
   // ...last entry just gets rounded up to near multiple of SPIRV_DATA_ALIGNMENT, which is 16 and
   // subtract the offset.
-  if (p_var->member_count > 0) {
-    SpvReflectBlockVariable* p_member_var = &p_var->members[p_var->member_count - 1];
-    p_member_var->padded_size = RoundUp(p_member_var->offset  + p_member_var->size, SPIRV_DATA_ALIGNMENT) - p_member_var->offset;
-    if (p_member_var->size > p_member_var->padded_size) {
-      p_member_var->size = p_member_var->padded_size;
-    }
-    if (is_parent_rta) {
-      p_member_var->padded_size = p_member_var->size;
-    }
+  // last entry == entry with largest offset value
+  SpvReflectBlockVariable* p_last_member_var = pp_member_offset_order[p_var->member_count - 1];
+  p_last_member_var->padded_size =
+      RoundUp(p_last_member_var->offset + p_last_member_var->size, SPIRV_DATA_ALIGNMENT) - p_last_member_var->offset;
+  if (p_last_member_var->size > p_last_member_var->padded_size) {
+    p_last_member_var->size = p_last_member_var->padded_size;
+  }
+  if (is_parent_rta) {
+    p_last_member_var->padded_size = p_last_member_var->size;
+  }
+
+  SafeFree(pp_member_offset_order);
+
+  // If buffer ref, sizes are same as uint64_t
+  if (is_parent_ref) {
+    p_var->size = p_var->padded_size = 8;
+    return SPV_REFLECT_RESULT_SUCCESS;
   }
 
   // @TODO validate this with assertion
-  p_var->size = p_var->members[p_var->member_count - 1].offset +
-                p_var->members[p_var->member_count - 1].padded_size;
+  p_var->size = p_last_member_var->offset + p_last_member_var->padded_size;
   p_var->padded_size = p_var->size;
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static void MarkSelfAndAllMemberVarsAsUsed(SpvReflectBlockVariable* p_var)
-{
-  // Clear the current variable's USED flag
+static void MarkSelfAndAllMemberVarsAsUsed(SpvReflectBlockVariable* p_var) {
+  // Clear the current variable's UNUSED flag
   p_var->flags &= ~SPV_REFLECT_VARIABLE_FLAGS_UNUSED;
 
   SpvOp op_type = p_var->type_description->op;
   switch (op_type) {
-    default: break;
+    default:
+      break;
 
     case SpvOpTypeArray: {
-    }
-    break;
+    } break;
 
     case SpvOpTypeStruct: {
       for (uint32_t i = 0; i < p_var->member_count; ++i) {
         SpvReflectBlockVariable* p_member_var = &p_var->members[i];
         MarkSelfAndAllMemberVarsAsUsed(p_member_var);
       }
-    }
-    break;
+    } break;
   }
 }
 
-static SpvReflectResult ParseDescriptorBlockVariableUsage(
-  Parser*                  p_parser,
-  SpvReflectShaderModule*  p_module,
-  AccessChain*             p_access_chain,
-  uint32_t                 index_index,
-  SpvOp                    override_op_type,
-  SpvReflectBlockVariable* p_var
-)
-{
-  (void)p_parser;
-  (void)p_access_chain;
-  (void)p_var;
-
+static SpvReflectResult ParseDescriptorBlockVariableUsage(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module,
+                                                          SpvReflectPrvAccessChain* p_access_chain, uint32_t index_index,
+                                                          SpvOp override_op_type, SpvReflectBlockVariable* p_var) {
   // Clear the current variable's UNUSED flag
   p_var->flags &= ~SPV_REFLECT_VARIABLE_FLAGS_UNUSED;
-  
+
   // Parsing arrays requires overriding the op type for
   // for the lowest dim's element type.
-  SpvOp op_type = p_var->type_description->op;
+  SpvReflectTypeDescription* p_type = p_var->type_description;
+  SpvOp op_type = p_type->op;
   if (override_op_type != (SpvOp)INVALID_VALUE) {
     op_type = override_op_type;
   }
 
   switch (op_type) {
-    default: break;
+    default:
+      break;
 
     case SpvOpTypeArray: {
       // Parse through array's type hierarchy to find the actual/non-array element type
-      SpvReflectTypeDescription* p_type = p_var->type_description;
       while ((p_type->op == SpvOpTypeArray) && (index_index < p_access_chain->index_count)) {
         // Find the array element type id
-        Node* p_node = FindNode(p_parser, p_type->id);
+        SpvReflectPrvNode* p_node = FindNode(p_parser, p_type->id);
         if (p_node == NULL) {
           return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
         }
@@ -2375,39 +2866,55 @@ static SpvReflectResult ParseDescriptorBlockVariableUsage(
         // Next access chain index
         index_index += 1;
       }
-      
+
       // Only continue parsing if there's remaining indices in the access
-      // chain. If the end of the access chain has been reach then all
+      // chain. If the end of the access chain has been reached then all
       // remaining variables (including those in struct hierarchies)
       // are considered USED.
       //
       // See: https://github.com/KhronosGroup/SPIRV-Reflect/issues/78
-      //  
+      //
       if (index_index < p_access_chain->index_count) {
         // Parse current var again with a type override and advanced index index
-        SpvReflectResult result = ParseDescriptorBlockVariableUsage(
-          p_parser,
-          p_module,
-          p_access_chain,
-          index_index,
-          p_type->op,
-          p_var);
+        SpvReflectResult result =
+            ParseDescriptorBlockVariableUsage(p_parser, p_module, p_access_chain, index_index, p_type->op, p_var);
         if (result != SPV_REFLECT_RESULT_SUCCESS) {
           return result;
         }
-      }
-      else {
+      } else {
         // Clear UNUSED flag for remaining variables
         MarkSelfAndAllMemberVarsAsUsed(p_var);
       }
+    } break;
+
+    case SpvOpTypePointer: {
+      // Reference. Get to underlying struct type.
+      SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
+      if (IsNull(p_type_node)) {
+        return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+      }
+      // Get the pointee type
+      p_type = FindType(p_module, p_type_node->type_id);
+      if (IsNull(p_type)) {
+        return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+      }
+      if (p_type->op != SpvOpTypeStruct) {
+        break;
+      }
+      FALLTHROUGH;
     }
-    break;
 
     case SpvOpTypeStruct: {
       assert(p_var->member_count > 0);
       if (p_var->member_count == 0) {
         return SPV_REFLECT_RESULT_ERROR_SPIRV_UNEXPECTED_BLOCK_DATA;
       }
+
+      // The access chain can have zero indexes, if used for a runtime array
+      if (p_access_chain->index_count == 0) {
+        return SPV_REFLECT_RESULT_SUCCESS;
+      }
+
       // Get member variable at the access's chain current index
       uint32_t index = p_access_chain->indexes[index_index];
       if (index >= p_var->member_count) {
@@ -2415,6 +2922,12 @@ static SpvReflectResult ParseDescriptorBlockVariableUsage(
       }
       SpvReflectBlockVariable* p_member_var = &p_var->members[index];
 
+      bool is_pointer_to_pointer = IsPointerToPointer(p_parser, p_access_chain->result_type_id);
+      if (is_pointer_to_pointer) {
+        // Remember block var for this access chain for downstream dereference
+        p_access_chain->block_var = p_member_var;
+      }
+
       // Next access chain index
       index_index += 1;
 
@@ -2426,82 +2939,57 @@ static SpvReflectResult ParseDescriptorBlockVariableUsage(
       // See: https://github.com/KhronosGroup/SPIRV-Reflect/issues/78
       //
       if (index_index < p_access_chain->index_count) {
-         SpvReflectResult result = ParseDescriptorBlockVariableUsage(
-           p_parser,
-           p_module,
-           p_access_chain,
-           index_index,
-           (SpvOp)INVALID_VALUE,
-           p_member_var);
-         if (result != SPV_REFLECT_RESULT_SUCCESS) {
-           return result;
-         }
-      }
-      else {
+        SpvReflectResult result =
+            ParseDescriptorBlockVariableUsage(p_parser, p_module, p_access_chain, index_index, (SpvOp)INVALID_VALUE, p_member_var);
+        if (result != SPV_REFLECT_RESULT_SUCCESS) {
+          return result;
+        }
+      } else if (!is_pointer_to_pointer) {
         // Clear UNUSED flag for remaining variables
         MarkSelfAndAllMemberVarsAsUsed(p_member_var);
       }
-      //SpvReflectBlockVariable* p_member_var = &p_var->members[index];
-      //if (index_index < p_access_chain->index_count) {
-      //  SpvReflectResult result = ParseDescriptorBlockVariableUsage(
-      //    p_parser,
-      //    p_module,
-      //    p_access_chain,
-      //    index_index + 1,
-      //    (SpvOp)INVALID_VALUE,
-      //    p_member_var);
-      //  if (result != SPV_REFLECT_RESULT_SUCCESS) {
-      //    return result;
-      //  }
-      //}
-    }
-    break;
+    } break;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseDescriptorBlocks(Parser* p_parser, SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseDescriptorBlocks(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
   if (p_module->descriptor_binding_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
   }
 
+  p_parser->physical_pointer_struct_count = 0;
+
   for (uint32_t descriptor_index = 0; descriptor_index < p_module->descriptor_binding_count; ++descriptor_index) {
     SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[descriptor_index]);
     SpvReflectTypeDescription* p_type = p_descriptor->type_description;
     if ((p_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_BUFFER) &&
-        (p_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER) )
-    {
+        (p_descriptor->descriptor_type != SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER)) {
       continue;
     }
 
     // Mark UNUSED
     p_descriptor->block.flags |= SPV_REFLECT_VARIABLE_FLAGS_UNUSED;
-    // Parse descriptor block 
+    p_parser->physical_pointer_count = 0;
+    // Parse descriptor block
     SpvReflectResult result = ParseDescriptorBlockVariable(p_parser, p_module, p_type, &p_descriptor->block);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
 
     for (uint32_t access_chain_index = 0; access_chain_index < p_parser->access_chain_count; ++access_chain_index) {
-      AccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
+      SpvReflectPrvAccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
       // Skip any access chains that aren't touching this descriptor block
       if (p_descriptor->spirv_id != p_access_chain->base_id) {
         continue;
       }
-      result = ParseDescriptorBlockVariableUsage(
-        p_parser,
-        p_module,
-        p_access_chain,
-        0,
-        (SpvOp)INVALID_VALUE,
-        &p_descriptor->block);
+      result = ParseDescriptorBlockVariableUsage(p_parser, p_module, p_access_chain, 0, (SpvOp)INVALID_VALUE, &p_descriptor->block);
       if (result != SPV_REFLECT_RESULT_SUCCESS) {
         return result;
       }
     }
-    
+
     p_descriptor->block.name = p_descriptor->name;
 
     bool is_parent_rta = (p_descriptor->descriptor_type == SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER);
@@ -2519,11 +3007,7 @@ static SpvReflectResult ParseDescriptorBlocks(Parser* p_parser, SpvReflectShader
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseFormat(
-  const SpvReflectTypeDescription*  p_type,
-  SpvReflectFormat*                 p_format
-)
-{
+static SpvReflectResult ParseFormat(const SpvReflectTypeDescription* p_type, SpvReflectFormat* p_format) {
   SpvReflectResult result = SPV_REFLECT_RESULT_ERROR_INTERNAL_ERROR;
   bool signedness = (p_type->traits.numeric.scalar.signedness != 0);
   uint32_t bit_width = p_type->traits.numeric.scalar.width;
@@ -2531,49 +3015,100 @@ static SpvReflectResult ParseFormat(
     uint32_t component_count = p_type->traits.numeric.vector.component_count;
     if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_FLOAT) {
       switch (bit_width) {
+        case 16: {
+          switch (component_count) {
+            case 2:
+              *p_format = SPV_REFLECT_FORMAT_R16G16_SFLOAT;
+              break;
+            case 3:
+              *p_format = SPV_REFLECT_FORMAT_R16G16B16_SFLOAT;
+              break;
+            case 4:
+              *p_format = SPV_REFLECT_FORMAT_R16G16B16A16_SFLOAT;
+              break;
+          }
+        } break;
+
         case 32: {
           switch (component_count) {
-            case 2: *p_format = SPV_REFLECT_FORMAT_R32G32_SFLOAT; break;
-            case 3: *p_format = SPV_REFLECT_FORMAT_R32G32B32_SFLOAT; break;
-            case 4: *p_format = SPV_REFLECT_FORMAT_R32G32B32A32_SFLOAT; break;
+            case 2:
+              *p_format = SPV_REFLECT_FORMAT_R32G32_SFLOAT;
+              break;
+            case 3:
+              *p_format = SPV_REFLECT_FORMAT_R32G32B32_SFLOAT;
+              break;
+            case 4:
+              *p_format = SPV_REFLECT_FORMAT_R32G32B32A32_SFLOAT;
+              break;
           }
-        }
-        break;
-        
+        } break;
+
         case 64: {
           switch (component_count) {
-            case 2: *p_format = SPV_REFLECT_FORMAT_R64G64_SFLOAT; break;
-            case 3: *p_format = SPV_REFLECT_FORMAT_R64G64B64_SFLOAT; break;
-            case 4: *p_format = SPV_REFLECT_FORMAT_R64G64B64A64_SFLOAT; break;
+            case 2:
+              *p_format = SPV_REFLECT_FORMAT_R64G64_SFLOAT;
+              break;
+            case 3:
+              *p_format = SPV_REFLECT_FORMAT_R64G64B64_SFLOAT;
+              break;
+            case 4:
+              *p_format = SPV_REFLECT_FORMAT_R64G64B64A64_SFLOAT;
+              break;
           }
         }
       }
       result = SPV_REFLECT_RESULT_SUCCESS;
-    }
-    else if (p_type->type_flags & (SPV_REFLECT_TYPE_FLAG_INT | SPV_REFLECT_TYPE_FLAG_BOOL)) {
+    } else if (p_type->type_flags & (SPV_REFLECT_TYPE_FLAG_INT | SPV_REFLECT_TYPE_FLAG_BOOL)) {
       switch (bit_width) {
+        case 16: {
+          switch (component_count) {
+            case 2:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R16G16_SINT : SPV_REFLECT_FORMAT_R16G16_UINT;
+              break;
+            case 3:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R16G16B16_SINT : SPV_REFLECT_FORMAT_R16G16B16_UINT;
+              break;
+            case 4:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R16G16B16A16_SINT : SPV_REFLECT_FORMAT_R16G16B16A16_UINT;
+              break;
+          }
+        } break;
+
         case 32: {
           switch (component_count) {
-            case 2: *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32_SINT : SPV_REFLECT_FORMAT_R32G32_UINT; break;
-            case 3: *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32B32_SINT : SPV_REFLECT_FORMAT_R32G32B32_UINT; break;
-            case 4: *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32B32A32_SINT : SPV_REFLECT_FORMAT_R32G32B32A32_UINT; break;
+            case 2:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32_SINT : SPV_REFLECT_FORMAT_R32G32_UINT;
+              break;
+            case 3:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32B32_SINT : SPV_REFLECT_FORMAT_R32G32B32_UINT;
+              break;
+            case 4:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R32G32B32A32_SINT : SPV_REFLECT_FORMAT_R32G32B32A32_UINT;
+              break;
           }
-        }
-        break;
-        
+        } break;
+
         case 64: {
           switch (component_count) {
-            case 2: *p_format = signedness ? SPV_REFLECT_FORMAT_R64G64_SINT : SPV_REFLECT_FORMAT_R64G64_UINT; break;
-            case 3: *p_format = signedness ? SPV_REFLECT_FORMAT_R64G64B64_SINT : SPV_REFLECT_FORMAT_R64G64B64_UINT; break;
-            case 4: *p_format = signedness ? SPV_REFLECT_FORMAT_R64G64B64A64_SINT : SPV_REFLECT_FORMAT_R64G64B64A64_UINT; break;
+            case 2:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R64G64_SINT : SPV_REFLECT_FORMAT_R64G64_UINT;
+              break;
+            case 3:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R64G64B64_SINT : SPV_REFLECT_FORMAT_R64G64B64_UINT;
+              break;
+            case 4:
+              *p_format = signedness ? SPV_REFLECT_FORMAT_R64G64B64A64_SINT : SPV_REFLECT_FORMAT_R64G64B64A64_UINT;
+              break;
           }
         }
       }
       result = SPV_REFLECT_RESULT_SUCCESS;
     }
-  }
-  else if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_FLOAT) {
-    switch(bit_width) {
+  } else if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_FLOAT) {
+    switch (bit_width) {
+      case 16:
+        *p_format = SPV_REFLECT_FORMAT_R16_SFLOAT;
+        break;
       case 32:
         *p_format = SPV_REFLECT_FORMAT_R32_SFLOAT;
         break;
@@ -2582,34 +3117,34 @@ static SpvReflectResult ParseFormat(
         break;
     }
     result = SPV_REFLECT_RESULT_SUCCESS;
-  }
-  else if (p_type->type_flags & (SPV_REFLECT_TYPE_FLAG_INT | SPV_REFLECT_TYPE_FLAG_BOOL)) {
-    switch(bit_width) {
+  } else if (p_type->type_flags & (SPV_REFLECT_TYPE_FLAG_INT | SPV_REFLECT_TYPE_FLAG_BOOL)) {
+    switch (bit_width) {
+      case 16:
+        *p_format = signedness ? SPV_REFLECT_FORMAT_R16_SINT : SPV_REFLECT_FORMAT_R16_UINT;
+        break;
+        break;
       case 32:
-        *p_format = signedness ? SPV_REFLECT_FORMAT_R32_SINT : SPV_REFLECT_FORMAT_R32_UINT; break;
+        *p_format = signedness ? SPV_REFLECT_FORMAT_R32_SINT : SPV_REFLECT_FORMAT_R32_UINT;
+        break;
         break;
       case 64:
-        *p_format = signedness ? SPV_REFLECT_FORMAT_R64_SINT : SPV_REFLECT_FORMAT_R64_UINT; break;
-    }        
+        *p_format = signedness ? SPV_REFLECT_FORMAT_R64_SINT : SPV_REFLECT_FORMAT_R64_UINT;
+        break;
+    }
     result = SPV_REFLECT_RESULT_SUCCESS;
-  }
-  else if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) {
+  } else if (p_type->type_flags & SPV_REFLECT_TYPE_FLAG_STRUCT) {
     *p_format = SPV_REFLECT_FORMAT_UNDEFINED;
     result = SPV_REFLECT_RESULT_SUCCESS;
   }
   return result;
 }
 
-static SpvReflectResult ParseInterfaceVariable(
-  Parser*                      p_parser,
-  const Decorations*           p_type_node_decorations,
-  SpvReflectShaderModule*      p_module,
-  SpvReflectTypeDescription*   p_type,
-  SpvReflectInterfaceVariable* p_var,
-  bool*                        p_has_built_in
-)
-{
-  Node* p_type_node = FindNode(p_parser, p_type->id);
+static SpvReflectResult ParseInterfaceVariable(SpvReflectPrvParser* p_parser,
+                                               const SpvReflectPrvDecorations* p_var_node_decorations,
+                                               const SpvReflectPrvDecorations* p_type_node_decorations,
+                                               SpvReflectShaderModule* p_module, SpvReflectTypeDescription* p_type,
+                                               SpvReflectInterfaceVariable* p_var, bool* p_has_built_in) {
+  SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
   if (IsNull(p_type_node)) {
     return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
   }
@@ -2622,10 +3157,15 @@ static SpvReflectResult ParseInterfaceVariable(
     }
 
     for (uint32_t member_index = 0; member_index < p_type_node->member_count; ++member_index) {
-      Decorations* p_member_decorations = &p_type_node->member_decorations[member_index];
+      SpvReflectPrvDecorations* p_member_decorations = &p_type_node->member_decorations[member_index];
       SpvReflectTypeDescription* p_member_type = &p_type->members[member_index];
       SpvReflectInterfaceVariable* p_member_var = &p_var->members[member_index];
-      SpvReflectResult result = ParseInterfaceVariable(p_parser, p_member_decorations, p_module, p_member_type, p_member_var, p_has_built_in);
+
+      // Storage class is the same throughout the whole struct
+      p_member_var->storage_class = p_var->storage_class;
+
+      SpvReflectResult result =
+          ParseInterfaceVariable(p_parser, NULL, p_member_decorations, p_module, p_member_type, p_member_var, p_has_built_in);
       if (result != SPV_REFLECT_RESULT_SUCCESS) {
         SPV_REFLECT_ASSERT(false);
         return result;
@@ -2635,6 +3175,14 @@ static SpvReflectResult ParseInterfaceVariable(
 
   p_var->name = p_type_node->name;
   p_var->decoration_flags = ApplyDecorations(p_type_node_decorations);
+  if (p_var_node_decorations != NULL) {
+    p_var->decoration_flags |= ApplyDecorations(p_var_node_decorations);
+  } else {
+    // Apply member decoration values to struct members
+    p_var->location = p_type_node_decorations->location.value;
+    p_var->component = p_type_node_decorations->component.value;
+  }
+
   p_var->built_in = p_type_node_decorations->built_in;
   ApplyNumericTraits(p_type, &p_var->numeric);
   if (p_type->op == SpvOpTypeArray) {
@@ -2657,52 +3205,49 @@ static SpvReflectResult ParseInterfaceVariable(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseInterfaceVariables(
-  Parser*                 p_parser,
-  SpvReflectShaderModule* p_module,
-  SpvReflectEntryPoint*   p_entry,
-  uint32_t                interface_variable_count,
-  uint32_t*               p_interface_variable_ids
-)
-{
+static SpvReflectResult ParseInterfaceVariables(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module,
+                                                SpvReflectEntryPoint* p_entry, uint32_t interface_variable_count,
+                                                uint32_t* p_interface_variable_ids) {
   if (interface_variable_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
   }
 
   p_entry->interface_variable_count = interface_variable_count;
- p_entry->input_variable_count = 0;
- p_entry->output_variable_count = 0;  
- for (size_t i = 0; i < interface_variable_count; ++i) {
-   uint32_t var_result_id = *(p_interface_variable_ids + i);
-   Node* p_node = FindNode(p_parser, var_result_id);
-   if (IsNull(p_node)) {
-     return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
-   }
- 
-   if (p_node->storage_class == SpvStorageClassInput) {
-     p_entry->input_variable_count += 1;
-   }
-   else if (p_node->storage_class == SpvStorageClassOutput) {
-     p_entry->output_variable_count += 1;
-   }
- }
- 
- if (p_entry->input_variable_count > 0) {
-   p_entry->input_variables = (SpvReflectInterfaceVariable**)calloc(p_entry->input_variable_count, sizeof(*(p_entry->input_variables)));
-   if (IsNull(p_entry->input_variables)) {
-     return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
-   }
- }
- 
- if (p_entry->output_variable_count > 0) {
-   p_entry->output_variables = (SpvReflectInterfaceVariable**)calloc(p_entry->output_variable_count, sizeof(*(p_entry->output_variables)));
-   if (IsNull(p_entry->output_variables)) {
-     return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
-   }
- }
+  p_entry->input_variable_count = 0;
+  p_entry->output_variable_count = 0;
+  for (size_t i = 0; i < interface_variable_count; ++i) {
+    uint32_t var_result_id = *(p_interface_variable_ids + i);
+    SpvReflectPrvNode* p_node = FindNode(p_parser, var_result_id);
+    if (IsNull(p_node)) {
+      return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+    }
+
+    if (p_node->storage_class == SpvStorageClassInput) {
+      p_entry->input_variable_count += 1;
+    } else if (p_node->storage_class == SpvStorageClassOutput) {
+      p_entry->output_variable_count += 1;
+    }
+  }
+
+  if (p_entry->input_variable_count > 0) {
+    p_entry->input_variables =
+        (SpvReflectInterfaceVariable**)calloc(p_entry->input_variable_count, sizeof(*(p_entry->input_variables)));
+    if (IsNull(p_entry->input_variables)) {
+      return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+    }
+  }
+
+  if (p_entry->output_variable_count > 0) {
+    p_entry->output_variables =
+        (SpvReflectInterfaceVariable**)calloc(p_entry->output_variable_count, sizeof(*(p_entry->output_variables)));
+    if (IsNull(p_entry->output_variables)) {
+      return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+    }
+  }
 
   if (p_entry->interface_variable_count > 0) {
-    p_entry->interface_variables = (SpvReflectInterfaceVariable*)calloc(p_entry->interface_variable_count, sizeof(*(p_entry->interface_variables)));
+    p_entry->interface_variables =
+        (SpvReflectInterfaceVariable*)calloc(p_entry->interface_variable_count, sizeof(*(p_entry->interface_variables)));
     if (IsNull(p_entry->interface_variables)) {
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
@@ -2712,19 +3257,19 @@ static SpvReflectResult ParseInterfaceVariables(
   size_t output_index = 0;
   for (size_t i = 0; i < interface_variable_count; ++i) {
     uint32_t var_result_id = *(p_interface_variable_ids + i);
-    Node* p_node = FindNode(p_parser, var_result_id);
+    SpvReflectPrvNode* p_node = FindNode(p_parser, var_result_id);
     if (IsNull(p_node)) {
       return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
     }
 
     SpvReflectTypeDescription* p_type = FindType(p_module, p_node->type_id);
-    if (IsNull(p_node)) {
+    if (IsNull(p_node) || IsNull(p_type)) {
       return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
     }
     // If the type is a pointer, resolve it
     if (p_type->op == SpvOpTypePointer) {
       // Find the type's node
-      Node* p_type_node = FindNode(p_parser, p_type->id);
+      SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
       if (IsNull(p_type_node)) {
         return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
       }
@@ -2735,22 +3280,17 @@ static SpvReflectResult ParseInterfaceVariables(
       }
     }
 
-    Node* p_type_node = FindNode(p_parser, p_type->id);
+    SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
     if (IsNull(p_type_node)) {
       return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
     }
 
     SpvReflectInterfaceVariable* p_var = &(p_entry->interface_variables[i]);
-    p_var->storage_class  = p_node->storage_class;
+    p_var->storage_class = p_node->storage_class;
 
     bool has_built_in = p_node->decorations.is_built_in;
-    SpvReflectResult result = ParseInterfaceVariable(
-      p_parser,
-      &p_type_node->decorations,
-      p_module,
-      p_type,
-      p_var,
-      &has_built_in);
+    SpvReflectResult result =
+        ParseInterfaceVariable(p_parser, &p_node->decorations, &p_type_node->decorations, p_module, p_type, p_var, &has_built_in);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       SPV_REFLECT_ASSERT(false);
       return result;
@@ -2759,9 +3299,8 @@ static SpvReflectResult ParseInterfaceVariables(
     // Input and output variables
     if (p_var->storage_class == SpvStorageClassInput) {
       p_entry->input_variables[input_index] = p_var;
-       ++input_index;
-    }
-    else if (p_node->storage_class == SpvStorageClassOutput) {
+      ++input_index;
+    } else if (p_node->storage_class == SpvStorageClassOutput) {
       p_entry->output_variables[output_index] = p_var;
       ++output_index;
     }
@@ -2780,6 +3319,7 @@ static SpvReflectResult ParseInterfaceVariables(
 
     // Location is decorated on OpVariable node, not the type node.
     p_var->location = p_node->decorations.location.value;
+    p_var->component = p_node->decorations.component.value;
     p_var->word_offset.location = p_node->decorations.location.word_offset;
 
     // Built in
@@ -2791,12 +3331,8 @@ static SpvReflectResult ParseInterfaceVariables(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult EnumerateAllPushConstants(
-  SpvReflectShaderModule* p_module,
-  size_t*                 p_push_constant_count,
-  uint32_t**              p_push_constants
-)
-{
+static SpvReflectResult EnumerateAllPushConstants(SpvReflectShaderModule* p_module, size_t* p_push_constant_count,
+                                                  uint32_t** p_push_constants) {
   *p_push_constant_count = p_module->push_constant_block_count;
   if (*p_push_constant_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
@@ -2810,19 +3346,12 @@ static SpvReflectResult EnumerateAllPushConstants(
   for (size_t i = 0; i < *p_push_constant_count; ++i) {
     (*p_push_constants)[i] = p_module->push_constant_blocks[i].spirv_id;
   }
-  qsort(*p_push_constants, *p_push_constant_count, sizeof(**p_push_constants),
-        SortCompareUint32);
+  qsort(*p_push_constants, *p_push_constant_count, sizeof(**p_push_constants), SortCompareUint32);
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult TraverseCallGraph(
-  Parser*   p_parser,
-  Function* p_func,
-  size_t*   p_func_count,
-  uint32_t* p_func_ids,
-  uint32_t  depth
-)
-{
+static SpvReflectResult TraverseCallGraph(SpvReflectPrvParser* p_parser, SpvReflectPrvFunction* p_func, size_t* p_func_count,
+                                          uint32_t* p_func_ids, uint32_t depth) {
   if (depth > p_parser->function_count) {
     // Vulkan does not permit recursion (Vulkan spec Appendix A):
     //   "Recursion: The static function-call graph for an entry point must not
@@ -2835,8 +3364,7 @@ static SpvReflectResult TraverseCallGraph(
     ++*p_func_count;
   }
   for (size_t i = 0; i < p_func->callee_count; ++i) {
-    SpvReflectResult result = TraverseCallGraph(
-        p_parser, p_func->callee_ptrs[i], p_func_count, p_func_ids, depth + 1);
+    SpvReflectResult result = TraverseCallGraph(p_parser, p_func->callee_ptrs[i], p_func_count, p_func_ids, depth + 1);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
@@ -2844,18 +3372,149 @@ static SpvReflectResult TraverseCallGraph(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseStaticallyUsedResources(
-  Parser*                 p_parser,
-  SpvReflectShaderModule* p_module,
-  SpvReflectEntryPoint*   p_entry,
-  size_t                  uniform_count,
-  uint32_t*               uniforms,
-  size_t                  push_constant_count,
-  uint32_t*               push_constants
-)
-{
+static uint32_t GetUint32Constant(SpvReflectPrvParser* p_parser, uint32_t id) {
+  uint32_t result = (uint32_t)INVALID_VALUE;
+  SpvReflectPrvNode* p_node = FindNode(p_parser, id);
+  if (p_node && p_node->op == SpvOpConstant) {
+    UNCHECKED_READU32(p_parser, p_node->word_offset + 3, result);
+  }
+  return result;
+}
+
+static bool HasByteAddressBufferOffset(SpvReflectPrvNode* p_node, SpvReflectDescriptorBinding* p_binding) {
+  return IsNotNull(p_node) && IsNotNull(p_binding) && p_node->op == SpvOpAccessChain && p_node->word_count == 6 &&
+         (p_binding->user_type == SPV_REFLECT_USER_TYPE_BYTE_ADDRESS_BUFFER ||
+          p_binding->user_type == SPV_REFLECT_USER_TYPE_RW_BYTE_ADDRESS_BUFFER);
+}
+
+static SpvReflectResult ParseByteAddressBuffer(SpvReflectPrvParser* p_parser, SpvReflectPrvNode* p_node,
+                                               SpvReflectDescriptorBinding* p_binding) {
+  const SpvReflectResult not_found = SPV_REFLECT_RESULT_SUCCESS;
+  if (!HasByteAddressBufferOffset(p_node, p_binding)) {
+    return not_found;
+  }
+
+  uint32_t offset = 0;  // starting offset
+
+  uint32_t base_id = 0;
+  // expect first index of 2D access is zero
+  UNCHECKED_READU32(p_parser, p_node->word_offset + 4, base_id);
+  if (GetUint32Constant(p_parser, base_id) != 0) {
+    return not_found;
+  }
+  UNCHECKED_READU32(p_parser, p_node->word_offset + 5, base_id);
+  SpvReflectPrvNode* p_next_node = FindNode(p_parser, base_id);
+  if (IsNull(p_next_node)) {
+    return not_found;
+  } else if (p_next_node->op == SpvOpConstant) {
+    // The access chain might just be a constant right to the offset
+    offset = GetUint32Constant(p_parser, base_id);
+    p_binding->byte_address_buffer_offsets[p_binding->byte_address_buffer_offset_count] = offset;
+    p_binding->byte_address_buffer_offset_count++;
+    return SPV_REFLECT_RESULT_SUCCESS;
+  }
+
+  // there is usually 2 (sometimes 3) instrucitons that make up the arithmetic logic to calculate the offset
+  SpvReflectPrvNode* arithmetic_node_stack[8];
+  uint32_t arithmetic_count = 0;
+
+  while (IsNotNull(p_next_node)) {
+    if (p_next_node->op == SpvOpLoad || p_next_node->op == SpvOpBitcast || p_next_node->op == SpvOpConstant) {
+      break;  // arithmetic starts here
+    }
+    arithmetic_node_stack[arithmetic_count++] = p_next_node;
+    if (arithmetic_count >= 8) {
+      return not_found;
+    }
+
+    UNCHECKED_READU32(p_parser, p_next_node->word_offset + 3, base_id);
+    p_next_node = FindNode(p_parser, base_id);
+  }
+
+  const uint32_t count = arithmetic_count;
+  for (uint32_t i = 0; i < count; i++) {
+    p_next_node = arithmetic_node_stack[--arithmetic_count];
+    // All arithmetic ops takes 2 operands, assumption is the 2nd operand has the constant
+    UNCHECKED_READU32(p_parser, p_next_node->word_offset + 4, base_id);
+    uint32_t value = GetUint32Constant(p_parser, base_id);
+    if (value == INVALID_VALUE) {
+      return not_found;
+    }
+
+    switch (p_next_node->op) {
+      case SpvOpShiftRightLogical:
+        offset >>= value;
+        break;
+      case SpvOpIAdd:
+        offset += value;
+        break;
+      case SpvOpISub:
+        offset -= value;
+        break;
+      case SpvOpIMul:
+        offset *= value;
+        break;
+      case SpvOpUDiv:
+        offset /= value;
+        break;
+      case SpvOpSDiv:
+        // OpConstant might be signed, but value should never be negative
+        assert((int32_t)value > 0);
+        offset /= value;
+        break;
+      default:
+        return not_found;
+    }
+  }
+
+  p_binding->byte_address_buffer_offsets[p_binding->byte_address_buffer_offset_count] = offset;
+  p_binding->byte_address_buffer_offset_count++;
+  return SPV_REFLECT_RESULT_SUCCESS;
+}
+
+static SpvReflectResult ParseFunctionParameterAccess(SpvReflectPrvParser* p_parser, uint32_t callee_function_id,
+                                                     uint32_t function_parameter_index, uint32_t* p_accessed) {
+  SpvReflectPrvFunction* p_func = NULL;
+  for (size_t i = 0; i < p_parser->function_count; ++i) {
+    if (p_parser->functions[i].id == callee_function_id) {
+      p_func = &(p_parser->functions[i]);
+      break;
+    }
+  }
+  if (p_func == NULL) {
+    return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
+  }
+
+  assert(function_parameter_index < p_func->parameter_count);
+
+  for (size_t i = 0; i < p_func->accessed_variable_count; ++i) {
+    if (p_func->parameters[function_parameter_index] == p_func->accessed_variables[i].variable_ptr) {
+      SpvReflectPrvAccessedVariable* p_var = &p_func->accessed_variables[i];
+      if (p_var->function_id > 0) {
+        SpvReflectResult result =
+            ParseFunctionParameterAccess(p_parser, p_var->function_id, p_var->function_parameter_index, p_accessed);
+        if (result != SPV_REFLECT_RESULT_SUCCESS) {
+          return result;
+        }
+      } else {
+        *p_accessed = 1;
+      }
+      // Early out as soon as p_accessed is true
+      if (*p_accessed) {
+        return SPV_REFLECT_RESULT_SUCCESS;
+      }
+    }
+  }
+
+  *p_accessed = 0;
+  return SPV_REFLECT_RESULT_SUCCESS;
+}
+
+static SpvReflectResult ParseStaticallyUsedResources(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module,
+                                                     SpvReflectEntryPoint* p_entry, size_t uniform_count, uint32_t* uniforms,
+                                                     size_t push_constant_count, uint32_t* push_constants) {
   // Find function with the right id
-  Function* p_func = NULL;
+  SpvReflectPrvFunction* p_func = NULL;
   for (size_t i = 0; i < p_parser->function_count; ++i) {
     if (p_parser->functions[i].id == p_entry->id) {
       p_func = &(p_parser->functions[i]);
@@ -2867,12 +3526,7 @@ static SpvReflectResult ParseStaticallyUsedResources(
   }
 
   size_t called_function_count = 0;
-  SpvReflectResult result = TraverseCallGraph(
-    p_parser,
-    p_func,
-    &called_function_count,
-    NULL,
-    0);
+  SpvReflectResult result = TraverseCallGraph(p_parser, p_func, &called_function_count, NULL, 0);
   if (result != SPV_REFLECT_RESULT_SUCCESS) {
     return result;
   }
@@ -2886,102 +3540,133 @@ static SpvReflectResult ParseStaticallyUsedResources(
   }
 
   called_function_count = 0;
-  result = TraverseCallGraph(
-    p_parser,
-    p_func,
-    &called_function_count,
-    p_called_functions,
-    0);
+  result = TraverseCallGraph(p_parser, p_func, &called_function_count, p_called_functions, 0);
   if (result != SPV_REFLECT_RESULT_SUCCESS) {
+    SafeFree(p_called_functions);
     return result;
   }
 
   if (called_function_count > 0) {
-    qsort(
-      p_called_functions, 
-      called_function_count, 
-      sizeof(*p_called_functions),
-      SortCompareUint32);
+    qsort(p_called_functions, called_function_count, sizeof(*p_called_functions), SortCompareUint32);
   }
   called_function_count = DedupSortedUint32(p_called_functions, called_function_count);
 
-  uint32_t used_variable_count = 0;
+  uint32_t used_acessed_count = 0;
   for (size_t i = 0, j = 0; i < called_function_count; ++i) {
     // No need to bounds check j because a missing ID issue would have been
     // found during TraverseCallGraph
     while (p_parser->functions[j].id != p_called_functions[i]) {
       ++j;
     }
-    used_variable_count += p_parser->functions[j].accessed_ptr_count;
+    used_acessed_count += p_parser->functions[j].accessed_variable_count;
   }
-  uint32_t* used_variables = NULL;
-  if (used_variable_count > 0) {
-    used_variables = (uint32_t*)calloc(used_variable_count,
-                                       sizeof(*used_variables));
-    if (IsNull(used_variables)) {
+  SpvReflectPrvAccessedVariable* p_used_accesses = NULL;
+  if (used_acessed_count > 0) {
+    p_used_accesses = (SpvReflectPrvAccessedVariable*)calloc(used_acessed_count, sizeof(SpvReflectPrvAccessedVariable));
+    if (IsNull(p_used_accesses)) {
       SafeFree(p_called_functions);
       return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
     }
   }
-  used_variable_count = 0;
+  used_acessed_count = 0;
   for (size_t i = 0, j = 0; i < called_function_count; ++i) {
     while (p_parser->functions[j].id != p_called_functions[i]) {
       ++j;
     }
 
-    memcpy(&used_variables[used_variable_count],
-           p_parser->functions[j].accessed_ptrs,
-           p_parser->functions[j].accessed_ptr_count * sizeof(*used_variables));
-    used_variable_count += p_parser->functions[j].accessed_ptr_count;
+    memcpy(&p_used_accesses[used_acessed_count], p_parser->functions[j].accessed_variables,
+           p_parser->functions[j].accessed_variable_count * sizeof(SpvReflectPrvAccessedVariable));
+    used_acessed_count += p_parser->functions[j].accessed_variable_count;
   }
   SafeFree(p_called_functions);
 
-  if (used_variable_count > 0) {
-    qsort(used_variables, used_variable_count, sizeof(*used_variables),
-          SortCompareUint32);
+  if (used_acessed_count > 0) {
+    qsort(p_used_accesses, used_acessed_count, sizeof(*p_used_accesses), SortCompareAccessedVariable);
   }
-  used_variable_count = (uint32_t)DedupSortedUint32(used_variables, 
-                                                    used_variable_count);
 
   // Do set intersection to find the used uniform and push constants
   size_t used_uniform_count = 0;
-  //
-  SpvReflectResult result0 = IntersectSortedUint32(
-    used_variables,
-    used_variable_count,
-    uniforms, 
-    uniform_count,
-    &p_entry->used_uniforms,
-    &used_uniform_count);
+  result = IntersectSortedAccessedVariable(p_used_accesses, used_acessed_count, uniforms, uniform_count, &p_entry->used_uniforms,
+                                           &used_uniform_count);
+  if (result != SPV_REFLECT_RESULT_SUCCESS) {
+    SafeFree(p_used_accesses);
+    return result;
+  }
 
   size_t used_push_constant_count = 0;
-  //
-  SpvReflectResult result1 = IntersectSortedUint32(
-    used_variables, 
-    used_variable_count,
-    push_constants, 
-    push_constant_count,
-    &p_entry->used_push_constants,
-    &used_push_constant_count);
+  result = IntersectSortedAccessedVariable(p_used_accesses, used_acessed_count, push_constants, push_constant_count,
+                                           &p_entry->used_push_constants, &used_push_constant_count);
+  if (result != SPV_REFLECT_RESULT_SUCCESS) {
+    SafeFree(p_used_accesses);
+    return result;
+  }
 
-  for (uint32_t j = 0; j < p_module->descriptor_binding_count; ++j) {
-    SpvReflectDescriptorBinding* p_binding = &p_module->descriptor_bindings[j];
-    bool found = SearchSortedUint32(
-      used_variables,
-      used_variable_count,
-      p_binding->spirv_id);
-    if (found) {
-      p_binding->accessed = 1;
+  for (uint32_t i = 0; i < p_module->descriptor_binding_count; ++i) {
+    SpvReflectDescriptorBinding* p_binding = &p_module->descriptor_bindings[i];
+    uint32_t byte_address_buffer_offset_count = 0;
+
+    for (uint32_t j = 0; j < used_acessed_count; j++) {
+      SpvReflectPrvAccessedVariable* p_var = &p_used_accesses[j];
+      if (p_var->variable_ptr == p_binding->spirv_id) {
+        if (p_var->function_id > 0) {
+          result =
+              ParseFunctionParameterAccess(p_parser, p_var->function_id, p_var->function_parameter_index, &p_binding->accessed);
+          if (result != SPV_REFLECT_RESULT_SUCCESS) {
+            SafeFree(p_used_accesses);
+            return result;
+          }
+        } else {
+          p_binding->accessed = 1;
+        }
+
+        if (HasByteAddressBufferOffset(p_used_accesses[j].p_node, p_binding)) {
+          byte_address_buffer_offset_count++;
+        }
+      }
+    }
+
+    // only if SPIR-V has ByteAddressBuffer user type
+    if (byte_address_buffer_offset_count > 0) {
+      bool multi_entrypoint = p_binding->byte_address_buffer_offset_count > 0;
+      if (multi_entrypoint) {
+        // If there is a 2nd entrypoint, we can have multiple entry points, in this case we want to just combine the accessed
+        // offsets and then de-duplicate it
+        uint32_t* prev_byte_address_buffer_offsets = p_binding->byte_address_buffer_offsets;
+        p_binding->byte_address_buffer_offsets =
+            (uint32_t*)calloc(byte_address_buffer_offset_count + p_binding->byte_address_buffer_offset_count, sizeof(uint32_t));
+        memcpy(p_binding->byte_address_buffer_offsets, prev_byte_address_buffer_offsets,
+               sizeof(uint32_t) * p_binding->byte_address_buffer_offset_count);
+        SafeFree(prev_byte_address_buffer_offsets);
+      } else {
+        // possible not all allocated offset slots are used, but this will be a max per binding
+        p_binding->byte_address_buffer_offsets = (uint32_t*)calloc(byte_address_buffer_offset_count, sizeof(uint32_t));
+      }
+
+      if (IsNull(p_binding->byte_address_buffer_offsets)) {
+        SafeFree(p_used_accesses);
+        return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+      }
+
+      for (uint32_t j = 0; j < used_acessed_count; j++) {
+        if (p_used_accesses[j].variable_ptr == p_binding->spirv_id) {
+          result = ParseByteAddressBuffer(p_parser, p_used_accesses[j].p_node, p_binding);
+          if (result != SPV_REFLECT_RESULT_SUCCESS) {
+            SafeFree(p_used_accesses);
+            return result;
+          }
+        }
+      }
+
+      if (multi_entrypoint) {
+        qsort(p_binding->byte_address_buffer_offsets, p_binding->byte_address_buffer_offset_count,
+              sizeof(*(p_binding->byte_address_buffer_offsets)), SortCompareUint32);
+        p_binding->byte_address_buffer_offset_count =
+            (uint32_t)DedupSortedUint32(p_binding->byte_address_buffer_offsets, p_binding->byte_address_buffer_offset_count);
+      }
     }
   }
 
-  SafeFree(used_variables);
-  if (result0 != SPV_REFLECT_RESULT_SUCCESS) {
-    return result0;
-  }
-  if (result1 != SPV_REFLECT_RESULT_SUCCESS) {
-    return result1;
-  }
+  SafeFree(p_used_accesses);
 
   p_entry->used_uniform_count = (uint32_t)used_uniform_count;
   p_entry->used_push_constant_count = (uint32_t)used_push_constant_count;
@@ -2989,15 +3674,13 @@ static SpvReflectResult ParseStaticallyUsedResources(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseEntryPoints(Parser* p_parser, SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseEntryPoints(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
   if (p_parser->entry_point_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
   }
 
   p_module->entry_point_count = p_parser->entry_point_count;
-  p_module->entry_points = (SpvReflectEntryPoint*)calloc(p_module->entry_point_count,
-                                                         sizeof(*(p_module->entry_points)));
+  p_module->entry_points = (SpvReflectEntryPoint*)calloc(p_module->entry_point_count, sizeof(*(p_module->entry_points)));
   if (IsNull(p_module->entry_points)) {
     return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
   }
@@ -3005,20 +3688,18 @@ static SpvReflectResult ParseEntryPoints(Parser* p_parser, SpvReflectShaderModul
   SpvReflectResult result;
   size_t uniform_count = 0;
   uint32_t* uniforms = NULL;
-  if ((result = EnumerateAllUniforms(p_module, &uniform_count, &uniforms)) !=
-       SPV_REFLECT_RESULT_SUCCESS) {
+  if ((result = EnumerateAllUniforms(p_module, &uniform_count, &uniforms)) != SPV_REFLECT_RESULT_SUCCESS) {
     return result;
   }
   size_t push_constant_count = 0;
   uint32_t* push_constants = NULL;
-  if ((result = EnumerateAllPushConstants(p_module, &push_constant_count, &push_constants)) !=
-       SPV_REFLECT_RESULT_SUCCESS) {
+  if ((result = EnumerateAllPushConstants(p_module, &push_constant_count, &push_constants)) != SPV_REFLECT_RESULT_SUCCESS) {
     return result;
   }
 
   size_t entry_point_index = 0;
   for (size_t i = 0; entry_point_index < p_parser->entry_point_count && i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
     if (p_node->op != SpvOpEntryPoint) {
       continue;
     }
@@ -3028,21 +3709,56 @@ static SpvReflectResult ParseEntryPoints(Parser* p_parser, SpvReflectShaderModul
     CHECKED_READU32(p_parser, p_node->word_offset + 2, p_entry_point->id);
 
     switch (p_entry_point->spirv_execution_model) {
-      default: break;
-      case SpvExecutionModelVertex                 : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_VERTEX_BIT; break;
-      case SpvExecutionModelTessellationControl    : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TESSELLATION_CONTROL_BIT; break;
-      case SpvExecutionModelTessellationEvaluation : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; break;
-      case SpvExecutionModelGeometry               : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_GEOMETRY_BIT; break;
-      case SpvExecutionModelFragment               : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_FRAGMENT_BIT; break;
-      case SpvExecutionModelGLCompute              : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_COMPUTE_BIT; break;
-      case SpvExecutionModelTaskNV                 : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TASK_BIT_NV; break;
-      case SpvExecutionModelMeshNV                 : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_MESH_BIT_NV; break;
-      case SpvExecutionModelRayGenerationKHR       : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_RAYGEN_BIT_KHR; break;
-      case SpvExecutionModelIntersectionKHR        : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_INTERSECTION_BIT_KHR; break;
-      case SpvExecutionModelAnyHitKHR              : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_ANY_HIT_BIT_KHR; break;
-      case SpvExecutionModelClosestHitKHR          : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_CLOSEST_HIT_BIT_KHR; break;
-      case SpvExecutionModelMissKHR                : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_MISS_BIT_KHR; break;
-      case SpvExecutionModelCallableKHR            : p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_CALLABLE_BIT_KHR; break;
+      default:
+        break;
+      case SpvExecutionModelVertex:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_VERTEX_BIT;
+        break;
+      case SpvExecutionModelTessellationControl:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
+        break;
+      case SpvExecutionModelTessellationEvaluation:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+        break;
+      case SpvExecutionModelGeometry:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_GEOMETRY_BIT;
+        break;
+      case SpvExecutionModelFragment:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_FRAGMENT_BIT;
+        break;
+      case SpvExecutionModelGLCompute:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_COMPUTE_BIT;
+        break;
+      case SpvExecutionModelTaskNV:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TASK_BIT_NV;
+        break;
+      case SpvExecutionModelTaskEXT:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_TASK_BIT_EXT;
+        break;
+      case SpvExecutionModelMeshNV:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_MESH_BIT_NV;
+        break;
+      case SpvExecutionModelMeshEXT:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_MESH_BIT_EXT;
+        break;
+      case SpvExecutionModelRayGenerationKHR:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_RAYGEN_BIT_KHR;
+        break;
+      case SpvExecutionModelIntersectionKHR:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_INTERSECTION_BIT_KHR;
+        break;
+      case SpvExecutionModelAnyHitKHR:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_ANY_HIT_BIT_KHR;
+        break;
+      case SpvExecutionModelClosestHitKHR:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
+        break;
+      case SpvExecutionModelMissKHR:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_MISS_BIT_KHR;
+        break;
+      case SpvExecutionModelCallableKHR:
+        p_entry_point->shader_stage = SPV_REFLECT_SHADER_STAGE_CALLABLE_BIT_KHR;
+        break;
     }
 
     ++entry_point_index;
@@ -3050,7 +3766,8 @@ static SpvReflectResult ParseEntryPoints(Parser* p_parser, SpvReflectShaderModul
     // Name length is required to calculate next operand
     uint32_t name_start_word_offset = 3;
     uint32_t name_length_with_terminator = 0;
-    result = ReadStr(p_parser, p_node->word_offset + name_start_word_offset, 0, p_node->word_count, &name_length_with_terminator, NULL);
+    result =
+        ReadStr(p_parser, p_node->word_offset + name_start_word_offset, 0, p_node->word_count, &name_length_with_terminator, NULL);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
@@ -3073,25 +3790,14 @@ static SpvReflectResult ParseEntryPoints(Parser* p_parser, SpvReflectShaderModul
       p_interface_variables[var_index] = var_result_id;
     }
 
-    result = ParseInterfaceVariables(
-      p_parser,
-      p_module,
-      p_entry_point,
-      interface_variable_count,
-      p_interface_variables);
+    result = ParseInterfaceVariables(p_parser, p_module, p_entry_point, interface_variable_count, p_interface_variables);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
     SafeFree(p_interface_variables);
 
-    result = ParseStaticallyUsedResources(
-      p_parser,
-      p_module,
-      p_entry_point,
-      uniform_count,
-      uniforms,
-      push_constant_count,
-      push_constants);
+    result = ParseStaticallyUsedResources(p_parser, p_module, p_entry_point, uniform_count, uniforms, push_constant_count,
+                                          push_constants);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
@@ -3103,24 +3809,23 @@ static SpvReflectResult ParseEntryPoints(Parser* p_parser, SpvReflectShaderModul
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseExecutionModes(Parser* p_parser, SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseExecutionModes(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
   assert(IsNotNull(p_parser));
   assert(IsNotNull(p_parser->nodes));
   assert(IsNotNull(p_module));
 
   if (IsNotNull(p_parser) && IsNotNull(p_parser->spirv_code) && IsNotNull(p_parser->nodes)) {
     for (size_t node_idx = 0; node_idx < p_parser->node_count; ++node_idx) {
-      Node* p_node = &(p_parser->nodes[node_idx]);
-      if (p_node->op != SpvOpExecutionMode) {
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[node_idx]);
+      if (p_node->op != SpvOpExecutionMode && p_node->op != SpvOpExecutionModeId) {
         continue;
       }
 
       // Read entry point id
       uint32_t entry_point_id = 0;
       CHECKED_READU32(p_parser, p_node->word_offset + 1, entry_point_id);
-      
-      // Find entry point 
+
+      // Find entry point
       SpvReflectEntryPoint* p_entry_point = NULL;
       for (size_t entry_point_idx = 0; entry_point_idx < p_module->entry_point_count; ++entry_point_idx) {
         if (p_module->entry_points[entry_point_idx].id == entry_point_id) {
@@ -3132,79 +3837,113 @@ static SpvReflectResult ParseExecutionModes(Parser* p_parser, SpvReflectShaderMo
       if (IsNull(p_entry_point)) {
         return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ENTRY_POINT;
       }
-      
+
       // Read execution mode
       uint32_t execution_mode = (uint32_t)INVALID_VALUE;
       CHECKED_READU32(p_parser, p_node->word_offset + 2, execution_mode);
 
       // Parse execution mode
       switch (execution_mode) {
-        default: {
-          return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_EXECUTION_MODE;
-        }
-        break;
-
-        case SpvExecutionModeInvocations:
-        case SpvExecutionModeSpacingEqual:
-        case SpvExecutionModeSpacingFractionalEven:
-        case SpvExecutionModeSpacingFractionalOdd:
-        case SpvExecutionModeVertexOrderCw:
-        case SpvExecutionModeVertexOrderCcw:
-        case SpvExecutionModePixelCenterInteger:
-        case SpvExecutionModeOriginUpperLeft:
-        case SpvExecutionModeOriginLowerLeft:
-        case SpvExecutionModeEarlyFragmentTests:
-        case SpvExecutionModePointMode:
-        case SpvExecutionModeXfb:
-        case SpvExecutionModeDepthReplacing:
-        case SpvExecutionModeDepthGreater:
-        case SpvExecutionModeDepthLess:
-        case SpvExecutionModeDepthUnchanged:
-          break;
+        case SpvExecutionModeInvocations: {
+          CHECKED_READU32(p_parser, p_node->word_offset + 3, p_entry_point->invocations);
+        } break;
 
         case SpvExecutionModeLocalSize: {
           CHECKED_READU32(p_parser, p_node->word_offset + 3, p_entry_point->local_size.x);
           CHECKED_READU32(p_parser, p_node->word_offset + 4, p_entry_point->local_size.y);
           CHECKED_READU32(p_parser, p_node->word_offset + 5, p_entry_point->local_size.z);
-        }
-        break;                                        
+        } break;
+        case SpvExecutionModeLocalSizeId: {
+          uint32_t local_size_x_id = 0;
+          uint32_t local_size_y_id = 0;
+          uint32_t local_size_z_id = 0;
+          CHECKED_READU32(p_parser, p_node->word_offset + 3, local_size_x_id);
+          CHECKED_READU32(p_parser, p_node->word_offset + 4, local_size_y_id);
+          CHECKED_READU32(p_parser, p_node->word_offset + 5, local_size_z_id);
 
-        case SpvExecutionModeLocalSizeHint:
-        case SpvExecutionModeInputPoints:
-        case SpvExecutionModeInputLines:
-        case SpvExecutionModeInputLinesAdjacency:
-        case SpvExecutionModeTriangles:
-        case SpvExecutionModeInputTrianglesAdjacency:
-        case SpvExecutionModeQuads:
-        case SpvExecutionModeIsolines:
-        case SpvExecutionModeOutputVertices:
-        case SpvExecutionModeOutputPoints:
-        case SpvExecutionModeOutputLineStrip:
-        case SpvExecutionModeOutputTriangleStrip:
-        case SpvExecutionModeVecTypeHint:
-        case SpvExecutionModeContractionOff:
-        case SpvExecutionModeInitializer:
-        case SpvExecutionModeFinalizer:
-        case SpvExecutionModeSubgroupSize:
-        case SpvExecutionModeSubgroupsPerWorkgroup:
-        case SpvExecutionModeSubgroupsPerWorkgroupId:
-        case SpvExecutionModeLocalSizeId:
-        case SpvExecutionModeLocalSizeHintId:
-        case SpvExecutionModePostDepthCoverage:
-        case SpvExecutionModeStencilRefReplacingEXT:
-        case SpvExecutionModeOutputPrimitivesNV:
-        case SpvExecutionModeOutputTrianglesNV:
+          SpvReflectPrvNode* x_node = FindNode(p_parser, local_size_x_id);
+          SpvReflectPrvNode* y_node = FindNode(p_parser, local_size_y_id);
+          SpvReflectPrvNode* z_node = FindNode(p_parser, local_size_z_id);
+          if (IsNotNull(x_node) && IsNotNull(y_node) && IsNotNull(z_node)) {
+            if (IsSpecConstant(x_node)) {
+              p_entry_point->local_size.x = (uint32_t)SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT;
+            } else {
+              CHECKED_READU32(p_parser, x_node->word_offset + 3, p_entry_point->local_size.x);
+            }
+
+            if (IsSpecConstant(y_node)) {
+              p_entry_point->local_size.y = (uint32_t)SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT;
+            } else {
+              CHECKED_READU32(p_parser, y_node->word_offset + 3, p_entry_point->local_size.y);
+            }
+
+            if (IsSpecConstant(z_node)) {
+              p_entry_point->local_size.z = (uint32_t)SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT;
+            } else {
+              CHECKED_READU32(p_parser, z_node->word_offset + 3, p_entry_point->local_size.z);
+            }
+          }
+        } break;
+
+        case SpvExecutionModeOutputVertices: {
+          CHECKED_READU32(p_parser, p_node->word_offset + 3, p_entry_point->output_vertices);
+        } break;
+
+        default:
           break;
       }
+      p_entry_point->execution_mode_count++;
     }
+    uint32_t* indices = (uint32_t*)calloc(p_module->entry_point_count, sizeof(indices));
+    if (IsNull(indices)) {
+      return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+    }
+    for (size_t entry_point_idx = 0; entry_point_idx < p_module->entry_point_count; ++entry_point_idx) {
+      SpvReflectEntryPoint* p_entry_point = &p_module->entry_points[entry_point_idx];
+      if (p_entry_point->execution_mode_count > 0) {
+        p_entry_point->execution_modes =
+            (SpvExecutionMode*)calloc(p_entry_point->execution_mode_count, sizeof(*p_entry_point->execution_modes));
+        if (IsNull(p_entry_point->execution_modes)) {
+          SafeFree(indices);
+          return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+        }
+      }
+    }
+
+    for (size_t node_idx = 0; node_idx < p_parser->node_count; ++node_idx) {
+      SpvReflectPrvNode* p_node = &(p_parser->nodes[node_idx]);
+      if (p_node->op != SpvOpExecutionMode) {
+        continue;
+      }
+
+      // Read entry point id
+      uint32_t entry_point_id = 0;
+      CHECKED_READU32(p_parser, p_node->word_offset + 1, entry_point_id);
+
+      // Find entry point
+      SpvReflectEntryPoint* p_entry_point = NULL;
+      uint32_t* idx = NULL;
+      for (size_t entry_point_idx = 0; entry_point_idx < p_module->entry_point_count; ++entry_point_idx) {
+        if (p_module->entry_points[entry_point_idx].id == entry_point_id) {
+          p_entry_point = &p_module->entry_points[entry_point_idx];
+          idx = &indices[entry_point_idx];
+          break;
+        }
+      }
+
+      // Read execution mode
+      uint32_t execution_mode = (uint32_t)INVALID_VALUE;
+      CHECKED_READU32(p_parser, p_node->word_offset + 2, execution_mode);
+      p_entry_point->execution_modes[(*idx)++] = (SpvExecutionMode)execution_mode;
+    }
+    SafeFree(indices);
   }
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParsePushConstantBlocks(Parser* p_parser, SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParsePushConstantBlocks(SpvReflectPrvParser* p_parser, SpvReflectShaderModule* p_module) {
   for (size_t i = 0; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
     if ((p_node->op != SpvOpVariable) || (p_node->storage_class != SpvStorageClassPushConstant)) {
       continue;
     }
@@ -3216,26 +3955,28 @@ static SpvReflectResult ParsePushConstantBlocks(Parser* p_parser, SpvReflectShad
     return SPV_REFLECT_RESULT_SUCCESS;
   }
 
-  p_module->push_constant_blocks = (SpvReflectBlockVariable*)calloc(p_module->push_constant_block_count, sizeof(*p_module->push_constant_blocks));
+  p_module->push_constant_blocks =
+      (SpvReflectBlockVariable*)calloc(p_module->push_constant_block_count, sizeof(*p_module->push_constant_blocks));
   if (IsNull(p_module->push_constant_blocks)) {
     return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
   }
 
+  p_parser->physical_pointer_struct_count = 0;
   uint32_t push_constant_index = 0;
   for (size_t i = 0; i < p_parser->node_count; ++i) {
-    Node* p_node = &(p_parser->nodes[i]);
+    SpvReflectPrvNode* p_node = &(p_parser->nodes[i]);
     if ((p_node->op != SpvOpVariable) || (p_node->storage_class != SpvStorageClassPushConstant)) {
       continue;
     }
 
     SpvReflectTypeDescription* p_type = FindType(p_module, p_node->type_id);
-    if (IsNull(p_node)) {
+    if (IsNull(p_node) || IsNull(p_type)) {
       return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
     }
     // If the type is a pointer, resolve it
     if (p_type->op == SpvOpTypePointer) {
       // Find the type's node
-      Node* p_type_node = FindNode(p_parser, p_type->id);
+      SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
       if (IsNull(p_type_node)) {
         return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
       }
@@ -3246,30 +3987,54 @@ static SpvReflectResult ParsePushConstantBlocks(Parser* p_parser, SpvReflectShad
       }
     }
 
-    Node* p_type_node = FindNode(p_parser, p_type->id);
+    SpvReflectPrvNode* p_type_node = FindNode(p_parser, p_type->id);
     if (IsNull(p_type_node)) {
       return SPV_REFLECT_RESULT_ERROR_SPIRV_INVALID_ID_REFERENCE;
     }
 
     SpvReflectBlockVariable* p_push_constant = &p_module->push_constant_blocks[push_constant_index];
     p_push_constant->spirv_id = p_node->result_id;
+    p_parser->physical_pointer_count = 0;
     SpvReflectResult result = ParseDescriptorBlockVariable(p_parser, p_module, p_type, p_push_constant);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
+
+    for (uint32_t access_chain_index = 0; access_chain_index < p_parser->access_chain_count; ++access_chain_index) {
+      SpvReflectPrvAccessChain* p_access_chain = &(p_parser->access_chains[access_chain_index]);
+      // Skip any access chains that aren't touching this push constant block
+      if (p_push_constant->spirv_id != FindAccessChainBaseVariable(p_parser, p_access_chain)) {
+        continue;
+      }
+      SpvReflectBlockVariable* p_var =
+          (p_access_chain->base_id == p_push_constant->spirv_id) ? p_push_constant : GetRefBlkVar(p_parser, p_access_chain);
+      result = ParseDescriptorBlockVariableUsage(p_parser, p_module, p_access_chain, 0, (SpvOp)INVALID_VALUE, p_var);
+      if (result != SPV_REFLECT_RESULT_SUCCESS) {
+        return result;
+      }
+    }
+
+    p_push_constant->name = p_node->name;
     result = ParseDescriptorBlockVariableSizes(p_parser, p_module, true, false, false, p_push_constant);
     if (result != SPV_REFLECT_RESULT_SUCCESS) {
       return result;
     }
 
+    // Get minimum offset for whole Push Constant block
+    // It is not valid SPIR-V to have an empty Push Constant Block
+    p_push_constant->offset = UINT32_MAX;
+    for (uint32_t k = 0; k < p_push_constant->member_count; ++k) {
+      const uint32_t member_offset = p_push_constant->members[k].offset;
+      p_push_constant->offset = Min(p_push_constant->offset, member_offset);
+    }
+
     ++push_constant_index;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static int SortCompareDescriptorSet(const void* a, const void* b)
-{
+static int SortCompareDescriptorSet(const void* a, const void* b) {
   const SpvReflectDescriptorSet* p_elem_a = (const SpvReflectDescriptorSet*)a;
   const SpvReflectDescriptorSet* p_elem_b = (const SpvReflectDescriptorSet*)b;
   int value = (int)(p_elem_a->set) - (int)(p_elem_b->set);
@@ -3291,10 +4056,7 @@ static SpvReflectResult ParseEntrypointDescriptorSets(SpvReflectShaderModule* p_
     for (uint32_t j = 0; j < p_module->descriptor_set_count; ++j) {
       const SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[j];
       for (uint32_t k = 0; k < p_set->binding_count; ++k) {
-        bool found = SearchSortedUint32(
-          p_entry->used_uniforms,
-          p_entry->used_uniform_count,
-          p_set->bindings[k]->spirv_id);
+        bool found = SearchSortedUint32(p_entry->used_uniforms, p_entry->used_uniform_count, p_set->bindings[k]->spirv_id);
         if (found) {
           ++p_entry->descriptor_set_count;
           break;
@@ -3304,8 +4066,7 @@ static SpvReflectResult ParseEntrypointDescriptorSets(SpvReflectShaderModule* p_
 
     p_entry->descriptor_sets = NULL;
     if (p_entry->descriptor_set_count > 0) {
-      p_entry->descriptor_sets = (SpvReflectDescriptorSet*)calloc(p_entry->descriptor_set_count,
-                                                                  sizeof(*p_entry->descriptor_sets));
+      p_entry->descriptor_sets = (SpvReflectDescriptorSet*)calloc(p_entry->descriptor_set_count, sizeof(*p_entry->descriptor_sets));
       if (IsNull(p_entry->descriptor_sets)) {
         return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
       }
@@ -3315,10 +4076,7 @@ static SpvReflectResult ParseEntrypointDescriptorSets(SpvReflectShaderModule* p_
       const SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[j];
       uint32_t count = 0;
       for (uint32_t k = 0; k < p_set->binding_count; ++k) {
-        bool found = SearchSortedUint32(
-          p_entry->used_uniforms,
-          p_entry->used_uniform_count,
-          p_set->bindings[k]->spirv_id);
+        bool found = SearchSortedUint32(p_entry->used_uniforms, p_entry->used_uniform_count, p_set->bindings[k]->spirv_id);
         if (found) {
           ++count;
         }
@@ -3326,19 +4084,14 @@ static SpvReflectResult ParseEntrypointDescriptorSets(SpvReflectShaderModule* p_
       if (count == 0) {
         continue;
       }
-      SpvReflectDescriptorSet* p_entry_set = &p_entry->descriptor_sets[
-          p_entry->descriptor_set_count++];
+      SpvReflectDescriptorSet* p_entry_set = &p_entry->descriptor_sets[p_entry->descriptor_set_count++];
       p_entry_set->set = p_set->set;
-      p_entry_set->bindings = (SpvReflectDescriptorBinding**)calloc(count,
-                                                                    sizeof(*p_entry_set->bindings));
+      p_entry_set->bindings = (SpvReflectDescriptorBinding**)calloc(count, sizeof(*p_entry_set->bindings));
       if (IsNull(p_entry_set->bindings)) {
         return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
       }
       for (uint32_t k = 0; k < p_set->binding_count; ++k) {
-        bool found = SearchSortedUint32(
-          p_entry->used_uniforms,
-          p_entry->used_uniform_count,
-          p_set->bindings[k]->spirv_id);
+        bool found = SearchSortedUint32(p_entry->used_uniforms, p_entry->used_uniform_count, p_set->bindings[k]->spirv_id);
         if (found) {
           p_entry_set->bindings[p_entry_set->binding_count++] = p_set->bindings[k];
         }
@@ -3349,8 +4102,7 @@ static SpvReflectResult ParseEntrypointDescriptorSets(SpvReflectShaderModule* p_
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult ParseDescriptorSets(SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult ParseDescriptorSets(SpvReflectShaderModule* p_module) {
   // Count the descriptors in each set
   for (uint32_t i = 0; i < p_module->descriptor_binding_count; ++i) {
     SpvReflectDescriptorBinding* p_descriptor = &(p_module->descriptor_bindings[i]);
@@ -3394,16 +4146,14 @@ static SpvReflectResult ParseDescriptorSets(SpvReflectShaderModule* p_module)
 
   // Sort the descriptor sets based on numbers
   if (p_module->descriptor_set_count > 0) {
-    qsort(p_module->descriptor_sets,
-          p_module->descriptor_set_count,
-          sizeof(*(p_module->descriptor_sets)),
+    qsort(p_module->descriptor_sets, p_module->descriptor_set_count, sizeof(*(p_module->descriptor_sets)),
           SortCompareDescriptorSet);
   }
 
   // Build descriptor pointer array
-  for (uint32_t i = 0; i <p_module->descriptor_set_count; ++i) {
+  for (uint32_t i = 0; i < p_module->descriptor_set_count; ++i) {
     SpvReflectDescriptorSet* p_set = &(p_module->descriptor_sets[i]);
-    p_set->bindings = (SpvReflectDescriptorBinding **)calloc(p_set->binding_count, sizeof(*(p_set->bindings)));
+    p_set->bindings = (SpvReflectDescriptorBinding**)calloc(p_set->binding_count, sizeof(*(p_set->bindings)));
 
     uint32_t descriptor_index = 0;
     for (uint32_t j = 0; j < p_module->descriptor_binding_count; ++j) {
@@ -3419,8 +4169,7 @@ static SpvReflectResult ParseDescriptorSets(SpvReflectShaderModule* p_module)
   return ParseEntrypointDescriptorSets(p_module);
 }
 
-static SpvReflectResult DisambiguateStorageBufferSrvUav(SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult DisambiguateStorageBufferSrvUav(SpvReflectShaderModule* p_module) {
   if (p_module->descriptor_binding_count == 0) {
     return SPV_REFLECT_RESULT_SUCCESS;
   }
@@ -3446,8 +4195,7 @@ static SpvReflectResult DisambiguateStorageBufferSrvUav(SpvReflectShaderModule*
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-static SpvReflectResult SynchronizeDescriptorSets(SpvReflectShaderModule* p_module)
-{
+static SpvReflectResult SynchronizeDescriptorSets(SpvReflectShaderModule* p_module) {
   // Free and reset all descriptor set numbers
   for (uint32_t i = 0; i < SPV_REFLECT_MAX_DESCRIPTOR_SETS; ++i) {
     SpvReflectDescriptorSet* p_set = &p_module->descriptor_sets[i];
@@ -3462,21 +4210,7 @@ static SpvReflectResult SynchronizeDescriptorSets(SpvReflectShaderModule* p_modu
   return result;
 }
 
-SpvReflectResult spvReflectGetShaderModule(
-  size_t                   size,
-  const void*              p_code,
-  SpvReflectShaderModule*  p_module
-)
-{
-  return spvReflectCreateShaderModule(size, p_code, p_module);
-}
-
-SpvReflectResult spvReflectCreateShaderModule(
-  size_t                   size,
-  const void*              p_code,
-  SpvReflectShaderModule*  p_module
-)
-{
+static SpvReflectResult CreateShaderModule(uint32_t flags, size_t size, const void* p_code, SpvReflectShaderModule* p_module) {
   // Initialize all module fields to zero
   memset(p_module, 0, sizeof(*p_module));
 
@@ -3489,20 +4223,37 @@ SpvReflectResult spvReflectCreateShaderModule(
   if (IsNull(p_module->_internal)) {
     return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
   }
-  // Allocate SPIR-V code storage
-  p_module->_internal->spirv_size = size;
-  p_module->_internal->spirv_code = (uint32_t*)calloc(1, p_module->_internal->spirv_size);
-  p_module->_internal->spirv_word_count = (uint32_t)(size / SPIRV_WORD_SIZE);
-  if (IsNull(p_module->_internal->spirv_code)) {
-    SafeFree(p_module->_internal);
-    return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+  // Copy flags
+  p_module->_internal->module_flags = flags;
+  // Figure out if we need to copy the SPIR-V code or not
+  if (flags & SPV_REFLECT_MODULE_FLAG_NO_COPY) {
+    // Set internal size and pointer to args passed in
+    p_module->_internal->spirv_size = size;
+#if defined(__cplusplus)
+    p_module->_internal->spirv_code = const_cast<uint32_t*>(static_cast<const uint32_t*>(p_code));  // cast that const away
+#else
+    p_module->_internal->spirv_code = (void*)p_code;  // cast that const away
+#endif
+    p_module->_internal->spirv_word_count = (uint32_t)(size / SPIRV_WORD_SIZE);
+  } else {
+    // Allocate SPIR-V code storage
+    p_module->_internal->spirv_size = size;
+    p_module->_internal->spirv_code = (uint32_t*)calloc(1, p_module->_internal->spirv_size);
+    p_module->_internal->spirv_word_count = (uint32_t)(size / SPIRV_WORD_SIZE);
+    if (IsNull(p_module->_internal->spirv_code)) {
+      SafeFree(p_module->_internal);
+      return SPV_REFLECT_RESULT_ERROR_ALLOC_FAILED;
+    }
+    // Copy SPIR-V to code storage
+    memcpy(p_module->_internal->spirv_code, p_code, size);
   }
-  memcpy(p_module->_internal->spirv_code, p_code, size);
 
-  Parser parser = { 0 };
-  SpvReflectResult result = CreateParser(p_module->_internal->spirv_size,
-                                         p_module->_internal->spirv_code,
-                                         &parser);
+  // Initialize everything to zero
+  SpvReflectPrvParser parser;
+  memset(&parser, 0, sizeof(SpvReflectPrvParser));
+
+  // Create parser
+  SpvReflectResult result = CreateParser(p_module->_internal->spirv_size, p_module->_internal->spirv_code, &parser);
 
   // Generator
   {
@@ -3535,7 +4286,7 @@ SpvReflectResult spvReflectCreateShaderModule(
     SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
   }
   if (result == SPV_REFLECT_RESULT_SUCCESS) {
-    result = ParseDecorations(&parser);
+    result = ParseDecorations(&parser, p_module);
     SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
   }
 
@@ -3580,6 +4331,10 @@ SpvReflectResult spvReflectCreateShaderModule(
     result = ParseEntryPoints(&parser, p_module);
     SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
   }
+  if (result == SPV_REFLECT_RESULT_SUCCESS) {
+    result = ParseCapabilities(&parser, p_module);
+    SPV_REFLECT_ASSERT(result == SPV_REFLECT_RESULT_SUCCESS);
+  }
   if (result == SPV_REFLECT_RESULT_SUCCESS && p_module->entry_point_count > 0) {
     SpvReflectEntryPoint* p_entry = &(p_module->entry_points[0]);
     p_module->entry_point_name = p_entry->name;
@@ -3616,9 +4371,20 @@ SpvReflectResult spvReflectCreateShaderModule(
   return result;
 }
 
-static void SafeFreeTypes(SpvReflectTypeDescription* p_type)
-{
-  if (IsNull(p_type)) {
+SpvReflectResult spvReflectCreateShaderModule(size_t size, const void* p_code, SpvReflectShaderModule* p_module) {
+  return CreateShaderModule(0, size, p_code, p_module);
+}
+
+SpvReflectResult spvReflectCreateShaderModule2(uint32_t flags, size_t size, const void* p_code, SpvReflectShaderModule* p_module) {
+  return CreateShaderModule(flags, size, p_code, p_module);
+}
+
+SpvReflectResult spvReflectGetShaderModule(size_t size, const void* p_code, SpvReflectShaderModule* p_module) {
+  return spvReflectCreateShaderModule(size, p_code, p_module);
+}
+
+static void SafeFreeTypes(SpvReflectTypeDescription* p_type) {
+  if (IsNull(p_type) || p_type->copied) {
     return;
   }
 
@@ -3633,12 +4399,16 @@ static void SafeFreeTypes(SpvReflectTypeDescription* p_type)
   }
 }
 
-static void SafeFreeBlockVariables(SpvReflectBlockVariable* p_block)
-{
+static void SafeFreeBlockVariables(SpvReflectBlockVariable* p_block) {
   if (IsNull(p_block)) {
     return;
   }
 
+  // We share pointers to Physical Pointer structs and don't want to double free
+  if (p_block->flags & SPV_REFLECT_VARIABLE_FLAGS_PHYSICAL_POINTER_COPY) {
+    return;
+  }
+
   if (IsNotNull(p_block->members)) {
     for (size_t i = 0; i < p_block->member_count; ++i) {
       SpvReflectBlockVariable* p_member = &p_block->members[i];
@@ -3650,8 +4420,7 @@ static void SafeFreeBlockVariables(SpvReflectBlockVariable* p_block)
   }
 }
 
-static void SafeFreeInterfaceVariable(SpvReflectInterfaceVariable* p_interface)
-{
+static void SafeFreeInterfaceVariable(SpvReflectInterfaceVariable* p_interface) {
   if (IsNull(p_interface)) {
     return;
   }
@@ -3667,8 +4436,7 @@ static void SafeFreeInterfaceVariable(SpvReflectInterfaceVariable* p_interface)
   }
 }
 
-void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module)
-{
+void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module) {
   if (IsNull(p_module->_internal)) {
     return;
   }
@@ -3684,6 +4452,9 @@ void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module)
   // Descriptor binding blocks
   for (size_t i = 0; i < p_module->descriptor_binding_count; ++i) {
     SpvReflectDescriptorBinding* p_descriptor = &p_module->descriptor_bindings[i];
+    if (IsNotNull(p_descriptor->byte_address_buffer_offsets)) {
+      SafeFree(p_descriptor->byte_address_buffer_offsets);
+    }
     SafeFreeBlockVariables(&p_descriptor->block);
   }
   SafeFree(p_module->descriptor_bindings);
@@ -3703,8 +4474,11 @@ void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module)
     SafeFree(p_entry->interface_variables);
     SafeFree(p_entry->used_uniforms);
     SafeFree(p_entry->used_push_constants);
+    SafeFree(p_entry->execution_modes);
   }
+  SafeFree(p_module->capabilities);
   SafeFree(p_module->entry_points);
+  SafeFree(p_module->spec_constants);
 
   // Push constants
   for (size_t i = 0; i < p_module->push_constant_block_count; ++i) {
@@ -3722,14 +4496,15 @@ void spvReflectDestroyShaderModule(SpvReflectShaderModule* p_module)
   }
   SafeFree(p_module->_internal->type_descriptions);
 
-  // Free SPIR-V code
-  SafeFree(p_module->_internal->spirv_code);
+  // Free SPIR-V code if there was a copy
+  if ((p_module->_internal->module_flags & SPV_REFLECT_MODULE_FLAG_NO_COPY) == 0) {
+    SafeFree(p_module->_internal->spirv_code);
+  }
   // Free internal
   SafeFree(p_module->_internal);
 }
 
-uint32_t spvReflectGetCodeSize(const SpvReflectShaderModule* p_module)
-{
+uint32_t spvReflectGetCodeSize(const SpvReflectShaderModule* p_module) {
   if (IsNull(p_module)) {
     return 0;
   }
@@ -3737,8 +4512,7 @@ uint32_t spvReflectGetCodeSize(const SpvReflectShaderModule* p_module)
   return (uint32_t)(p_module->_internal->spirv_size);
 }
 
-const uint32_t* spvReflectGetCode(const SpvReflectShaderModule* p_module)
-{
+const uint32_t* spvReflectGetCode(const SpvReflectShaderModule* p_module) {
   if (IsNull(p_module)) {
     return NULL;
   }
@@ -3746,10 +4520,7 @@ const uint32_t* spvReflectGetCode(const SpvReflectShaderModule* p_module)
   return p_module->_internal->spirv_code;
 }
 
-const SpvReflectEntryPoint* spvReflectGetEntryPoint(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point
-) {
+const SpvReflectEntryPoint* spvReflectGetEntryPoint(const SpvReflectShaderModule* p_module, const char* entry_point) {
   if (IsNull(p_module) || IsNull(entry_point)) {
     return NULL;
   }
@@ -3762,12 +4533,8 @@ const SpvReflectEntryPoint* spvReflectGetEntryPoint(
   return NULL;
 }
 
-SpvReflectResult spvReflectEnumerateDescriptorBindings(
-  const SpvReflectShaderModule*  p_module,
-  uint32_t*                      p_count,
-  SpvReflectDescriptorBinding**  pp_bindings
-)
-{
+SpvReflectResult spvReflectEnumerateDescriptorBindings(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                       SpvReflectDescriptorBinding** pp_bindings) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -3784,21 +4551,15 @@ SpvReflectResult spvReflectEnumerateDescriptorBindings(
       SpvReflectDescriptorBinding* p_bindings = (SpvReflectDescriptorBinding*)&p_module->descriptor_bindings[index];
       pp_bindings[index] = p_bindings;
     }
-  }
-  else {
+  } else {
     *p_count = p_module->descriptor_binding_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateEntryPointDescriptorBindings(
-  const SpvReflectShaderModule*  p_module,
-  const char*                    entry_point,
-  uint32_t*                      p_count,
-  SpvReflectDescriptorBinding**  pp_bindings
-)
-{
+SpvReflectResult spvReflectEnumerateEntryPointDescriptorBindings(const SpvReflectShaderModule* p_module, const char* entry_point,
+                                                                 uint32_t* p_count, SpvReflectDescriptorBinding** pp_bindings) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -3806,18 +4567,14 @@ SpvReflectResult spvReflectEnumerateEntryPointDescriptorBindings(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
 
-  const SpvReflectEntryPoint* p_entry =
-      spvReflectGetEntryPoint(p_module, entry_point);
+  const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
   if (IsNull(p_entry)) {
     return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
   }
 
   uint32_t count = 0;
   for (uint32_t i = 0; i < p_module->descriptor_binding_count; ++i) {
-    bool found = SearchSortedUint32(
-      p_entry->used_uniforms,
-      p_entry->used_uniform_count,
-      p_module->descriptor_bindings[i].spirv_id);
+    bool found = SearchSortedUint32(p_entry->used_uniforms, p_entry->used_uniform_count, p_module->descriptor_bindings[i].spirv_id);
     if (found) {
       if (IsNotNull(pp_bindings)) {
         if (count >= *p_count) {
@@ -3839,12 +4596,8 @@ SpvReflectResult spvReflectEnumerateEntryPointDescriptorBindings(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateDescriptorSets(
-  const SpvReflectShaderModule* p_module,
-  uint32_t*                     p_count,
-  SpvReflectDescriptorSet**     pp_sets
-)
-{
+SpvReflectResult spvReflectEnumerateDescriptorSets(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                   SpvReflectDescriptorSet** pp_sets) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -3861,21 +4614,15 @@ SpvReflectResult spvReflectEnumerateDescriptorSets(
       SpvReflectDescriptorSet* p_set = (SpvReflectDescriptorSet*)&p_module->descriptor_sets[index];
       pp_sets[index] = p_set;
     }
-  }
-  else {
+  } else {
     *p_count = p_module->descriptor_set_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateEntryPointDescriptorSets(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t*                     p_count,
-  SpvReflectDescriptorSet**     pp_sets
-)
-{
+SpvReflectResult spvReflectEnumerateEntryPointDescriptorSets(const SpvReflectShaderModule* p_module, const char* entry_point,
+                                                             uint32_t* p_count, SpvReflectDescriptorSet** pp_sets) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -3883,8 +4630,7 @@ SpvReflectResult spvReflectEnumerateEntryPointDescriptorSets(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
 
-  const SpvReflectEntryPoint* p_entry =
-      spvReflectGetEntryPoint(p_module, entry_point);
+  const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
   if (IsNull(p_entry)) {
     return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
   }
@@ -3898,20 +4644,15 @@ SpvReflectResult spvReflectEnumerateEntryPointDescriptorSets(
       SpvReflectDescriptorSet* p_set = (SpvReflectDescriptorSet*)&p_entry->descriptor_sets[index];
       pp_sets[index] = p_set;
     }
-  }
-  else {
+  } else {
     *p_count = p_entry->descriptor_set_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateInterfaceVariables(
-  const SpvReflectShaderModule* p_module,
-  uint32_t*                     p_count,
-  SpvReflectInterfaceVariable** pp_variables
-)
-{
+SpvReflectResult spvReflectEnumerateInterfaceVariables(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                       SpvReflectInterfaceVariable** pp_variables) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -3928,21 +4669,15 @@ SpvReflectResult spvReflectEnumerateInterfaceVariables(
       SpvReflectInterfaceVariable* p_var = &p_module->interface_variables[index];
       pp_variables[index] = p_var;
     }
-  }
-  else {
+  } else {
     *p_count = p_module->interface_variable_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateEntryPointInterfaceVariables(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t*                     p_count,
-  SpvReflectInterfaceVariable** pp_variables
-)
-{
+SpvReflectResult spvReflectEnumerateEntryPointInterfaceVariables(const SpvReflectShaderModule* p_module, const char* entry_point,
+                                                                 uint32_t* p_count, SpvReflectInterfaceVariable** pp_variables) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -3950,8 +4685,7 @@ SpvReflectResult spvReflectEnumerateEntryPointInterfaceVariables(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
 
-  const SpvReflectEntryPoint* p_entry =
-      spvReflectGetEntryPoint(p_module, entry_point);
+  const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
   if (IsNull(p_entry)) {
     return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
   }
@@ -3965,20 +4699,15 @@ SpvReflectResult spvReflectEnumerateEntryPointInterfaceVariables(
       SpvReflectInterfaceVariable* p_var = &p_entry->interface_variables[index];
       pp_variables[index] = p_var;
     }
-  }
-  else {
+  } else {
     *p_count = p_entry->interface_variable_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateInputVariables(
-  const SpvReflectShaderModule* p_module,
-  uint32_t*                     p_count,
-  SpvReflectInterfaceVariable** pp_variables
-)
-{
+SpvReflectResult spvReflectEnumerateInputVariables(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                   SpvReflectInterfaceVariable** pp_variables) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -3995,21 +4724,15 @@ SpvReflectResult spvReflectEnumerateInputVariables(
       SpvReflectInterfaceVariable* p_var = p_module->input_variables[index];
       pp_variables[index] = p_var;
     }
-  }
-  else {
+  } else {
     *p_count = p_module->input_variable_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateEntryPointInputVariables(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t*                     p_count,
-  SpvReflectInterfaceVariable** pp_variables
-)
-{
+SpvReflectResult spvReflectEnumerateEntryPointInputVariables(const SpvReflectShaderModule* p_module, const char* entry_point,
+                                                             uint32_t* p_count, SpvReflectInterfaceVariable** pp_variables) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4017,8 +4740,7 @@ SpvReflectResult spvReflectEnumerateEntryPointInputVariables(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
 
-  const SpvReflectEntryPoint* p_entry =
-      spvReflectGetEntryPoint(p_module, entry_point);
+  const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
   if (IsNull(p_entry)) {
     return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
   }
@@ -4032,20 +4754,15 @@ SpvReflectResult spvReflectEnumerateEntryPointInputVariables(
       SpvReflectInterfaceVariable* p_var = p_entry->input_variables[index];
       pp_variables[index] = p_var;
     }
-  }
-  else {
+  } else {
     *p_count = p_entry->input_variable_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateOutputVariables(
-  const SpvReflectShaderModule* p_module,
-  uint32_t*                     p_count,
-  SpvReflectInterfaceVariable** pp_variables
-)
-{
+SpvReflectResult spvReflectEnumerateOutputVariables(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                    SpvReflectInterfaceVariable** pp_variables) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4062,21 +4779,15 @@ SpvReflectResult spvReflectEnumerateOutputVariables(
       SpvReflectInterfaceVariable* p_var = p_module->output_variables[index];
       pp_variables[index] = p_var;
     }
-  }
-  else {
+  } else {
     *p_count = p_module->output_variable_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumerateEntryPointOutputVariables(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t*                     p_count,
-  SpvReflectInterfaceVariable** pp_variables
-)
-{
+SpvReflectResult spvReflectEnumerateEntryPointOutputVariables(const SpvReflectShaderModule* p_module, const char* entry_point,
+                                                              uint32_t* p_count, SpvReflectInterfaceVariable** pp_variables) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4084,8 +4795,7 @@ SpvReflectResult spvReflectEnumerateEntryPointOutputVariables(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
 
-  const SpvReflectEntryPoint* p_entry =
-      spvReflectGetEntryPoint(p_module, entry_point);
+  const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
   if (IsNull(p_entry)) {
     return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
   }
@@ -4099,20 +4809,15 @@ SpvReflectResult spvReflectEnumerateEntryPointOutputVariables(
       SpvReflectInterfaceVariable* p_var = p_entry->output_variables[index];
       pp_variables[index] = p_var;
     }
-  }
-  else {
+  } else {
     *p_count = p_entry->output_variable_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectEnumeratePushConstantBlocks(
-  const SpvReflectShaderModule* p_module,
-  uint32_t*                     p_count,
-  SpvReflectBlockVariable**     pp_blocks
-)
-{
+SpvReflectResult spvReflectEnumeratePushConstantBlocks(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                       SpvReflectBlockVariable** pp_blocks) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4129,29 +4834,19 @@ SpvReflectResult spvReflectEnumeratePushConstantBlocks(
       SpvReflectBlockVariable* p_push_constant_blocks = (SpvReflectBlockVariable*)&p_module->push_constant_blocks[index];
       pp_blocks[index] = p_push_constant_blocks;
     }
-  }
-  else {
+  } else {
     *p_count = p_module->push_constant_block_count;
   }
 
   return SPV_REFLECT_RESULT_SUCCESS;
 }
-SpvReflectResult spvReflectEnumeratePushConstants(
-  const SpvReflectShaderModule* p_module,
-  uint32_t*                     p_count,
-  SpvReflectBlockVariable**     pp_blocks
-)
-{
+SpvReflectResult spvReflectEnumeratePushConstants(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                  SpvReflectBlockVariable** pp_blocks) {
   return spvReflectEnumeratePushConstantBlocks(p_module, p_count, pp_blocks);
 }
 
-SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t*                     p_count,
-  SpvReflectBlockVariable**     pp_blocks
-)
-{
+SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(const SpvReflectShaderModule* p_module, const char* entry_point,
+                                                                 uint32_t* p_count, SpvReflectBlockVariable** pp_blocks) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4159,18 +4854,15 @@ SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
 
-
-  const SpvReflectEntryPoint* p_entry =
-      spvReflectGetEntryPoint(p_module, entry_point);
+  const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
   if (IsNull(p_entry)) {
     return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
   }
 
   uint32_t count = 0;
   for (uint32_t i = 0; i < p_module->push_constant_block_count; ++i) {
-    bool found = SearchSortedUint32(p_entry->used_push_constants,
-                           p_entry->used_push_constant_count,
-                           p_module->push_constant_blocks[i].spirv_id);
+    bool found = SearchSortedUint32(p_entry->used_push_constants, p_entry->used_push_constant_count,
+                                    p_module->push_constant_blocks[i].spirv_id);
     if (found) {
       if (IsNotNull(pp_blocks)) {
         if (count >= *p_count) {
@@ -4192,13 +4884,33 @@ SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-const SpvReflectDescriptorBinding* spvReflectGetDescriptorBinding(
-  const SpvReflectShaderModule* p_module,
-  uint32_t                      binding_number,
-  uint32_t                      set_number,
-  SpvReflectResult*             p_result
-)
-{
+SpvReflectResult spvReflectEnumerateSpecializationConstants(const SpvReflectShaderModule* p_module, uint32_t* p_count,
+                                                            SpvReflectSpecializationConstant** pp_constants) {
+  if (IsNull(p_module)) {
+    return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
+  }
+  if (IsNull(p_count)) {
+    return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
+  }
+
+  if (IsNotNull(pp_constants)) {
+    if (*p_count != p_module->spec_constant_count) {
+      return SPV_REFLECT_RESULT_ERROR_COUNT_MISMATCH;
+    }
+
+    for (uint32_t index = 0; index < *p_count; ++index) {
+      SpvReflectSpecializationConstant* p_constant = (SpvReflectSpecializationConstant*)&p_module->spec_constants[index];
+      pp_constants[index] = p_constant;
+    }
+  } else {
+    *p_count = p_module->spec_constant_count;
+  }
+
+  return SPV_REFLECT_RESULT_SUCCESS;
+}
+
+const SpvReflectDescriptorBinding* spvReflectGetDescriptorBinding(const SpvReflectShaderModule* p_module, uint32_t binding_number,
+                                                                  uint32_t set_number, SpvReflectResult* p_result) {
   const SpvReflectDescriptorBinding* p_descriptor = NULL;
   if (IsNotNull(p_module)) {
     for (uint32_t index = 0; index < p_module->descriptor_binding_count; ++index) {
@@ -4211,23 +4923,16 @@ const SpvReflectDescriptorBinding* spvReflectGetDescriptorBinding(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_descriptor)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_descriptor;
 }
 
-const SpvReflectDescriptorBinding* spvReflectGetEntryPointDescriptorBinding(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t                      binding_number,
-  uint32_t                      set_number,
-  SpvReflectResult*             p_result
-)
-{
-  const SpvReflectEntryPoint* p_entry =
-      spvReflectGetEntryPoint(p_module, entry_point);
+const SpvReflectDescriptorBinding* spvReflectGetEntryPointDescriptorBinding(const SpvReflectShaderModule* p_module,
+                                                                            const char* entry_point, uint32_t binding_number,
+                                                                            uint32_t set_number, SpvReflectResult* p_result) {
+  const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
   if (IsNull(p_entry)) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
@@ -4238,10 +4943,7 @@ const SpvReflectDescriptorBinding* spvReflectGetEntryPointDescriptorBinding(
   if (IsNotNull(p_module)) {
     for (uint32_t index = 0; index < p_module->descriptor_binding_count; ++index) {
       const SpvReflectDescriptorBinding* p_potential = &p_module->descriptor_bindings[index];
-      bool found = SearchSortedUint32(
-        p_entry->used_uniforms, 
-        p_entry->used_uniform_count,
-        p_potential->spirv_id);
+      bool found = SearchSortedUint32(p_entry->used_uniforms, p_entry->used_uniform_count, p_potential->spirv_id);
       if ((p_potential->binding == binding_number) && (p_potential->set == set_number) && found) {
         p_descriptor = p_potential;
         break;
@@ -4250,19 +4952,14 @@ const SpvReflectDescriptorBinding* spvReflectGetEntryPointDescriptorBinding(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_descriptor)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_descriptor;
 }
 
-const SpvReflectDescriptorSet* spvReflectGetDescriptorSet(
-  const SpvReflectShaderModule* p_module,
-  uint32_t                      set_number,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectDescriptorSet* spvReflectGetDescriptorSet(const SpvReflectShaderModule* p_module, uint32_t set_number,
+                                                          SpvReflectResult* p_result) {
   const SpvReflectDescriptorSet* p_set = NULL;
   if (IsNotNull(p_module)) {
     for (uint32_t index = 0; index < p_module->descriptor_set_count; ++index) {
@@ -4274,19 +4971,14 @@ const SpvReflectDescriptorSet* spvReflectGetDescriptorSet(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_set)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_set;
 }
 
-const SpvReflectDescriptorSet* spvReflectGetEntryPointDescriptorSet(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t                      set_number,
-  SpvReflectResult*             p_result)
-{
+const SpvReflectDescriptorSet* spvReflectGetEntryPointDescriptorSet(const SpvReflectShaderModule* p_module, const char* entry_point,
+                                                                    uint32_t set_number, SpvReflectResult* p_result) {
   const SpvReflectDescriptorSet* p_set = NULL;
   if (IsNotNull(p_module)) {
     const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
@@ -4305,20 +4997,14 @@ const SpvReflectDescriptorSet* spvReflectGetEntryPointDescriptorSet(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_set)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_set;
 }
 
-
-const SpvReflectInterfaceVariable* spvReflectGetInputVariableByLocation(
-  const SpvReflectShaderModule* p_module,
-  uint32_t                      location,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetInputVariableByLocation(const SpvReflectShaderModule* p_module, uint32_t location,
+                                                                        SpvReflectResult* p_result) {
   if (location == INVALID_VALUE) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
@@ -4336,28 +5022,19 @@ const SpvReflectInterfaceVariable* spvReflectGetInputVariableByLocation(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
-const SpvReflectInterfaceVariable* spvReflectGetInputVariable(
-  const SpvReflectShaderModule* p_module,
-  uint32_t                      location,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetInputVariable(const SpvReflectShaderModule* p_module, uint32_t location,
+                                                              SpvReflectResult* p_result) {
   return spvReflectGetInputVariableByLocation(p_module, location, p_result);
 }
 
-const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableByLocation(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t                      location,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableByLocation(const SpvReflectShaderModule* p_module,
+                                                                                  const char* entry_point, uint32_t location,
+                                                                                  SpvReflectResult* p_result) {
   if (location == INVALID_VALUE) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
@@ -4367,8 +5044,7 @@ const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableByLocatio
 
   const SpvReflectInterfaceVariable* p_var = NULL;
   if (IsNotNull(p_module)) {
-    const SpvReflectEntryPoint* p_entry =
-        spvReflectGetEntryPoint(p_module, entry_point);
+    const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
     if (IsNull(p_entry)) {
       if (IsNotNull(p_result)) {
         *p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
@@ -4384,19 +5060,14 @@ const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableByLocatio
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
 
-const SpvReflectInterfaceVariable* spvReflectGetInputVariableBySemantic(
-  const SpvReflectShaderModule* p_module,
-  const char*                   semantic,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetInputVariableBySemantic(const SpvReflectShaderModule* p_module,
+                                                                        const char* semantic, SpvReflectResult* p_result) {
   if (IsNull(semantic)) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
@@ -4420,20 +5091,15 @@ const SpvReflectInterfaceVariable* spvReflectGetInputVariableBySemantic(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-      ?  SPV_REFLECT_RESULT_SUCCESS
-      : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-        : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
 
-const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableBySemantic(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  const char*                   semantic,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableBySemantic(const SpvReflectShaderModule* p_module,
+                                                                                  const char* entry_point, const char* semantic,
+                                                                                  SpvReflectResult* p_result) {
   if (IsNull(semantic)) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
@@ -4464,19 +5130,14 @@ const SpvReflectInterfaceVariable* spvReflectGetEntryPointInputVariableBySemanti
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-      ?  SPV_REFLECT_RESULT_SUCCESS
-      : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-        : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
 
-const SpvReflectInterfaceVariable* spvReflectGetOutputVariableByLocation(
-  const SpvReflectShaderModule*  p_module,
-  uint32_t                       location,
-  SpvReflectResult*              p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetOutputVariableByLocation(const SpvReflectShaderModule* p_module, uint32_t location,
+                                                                         SpvReflectResult* p_result) {
   if (location == INVALID_VALUE) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
@@ -4494,28 +5155,19 @@ const SpvReflectInterfaceVariable* spvReflectGetOutputVariableByLocation(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
-const SpvReflectInterfaceVariable* spvReflectGetOutputVariable(
-  const SpvReflectShaderModule*  p_module,
-  uint32_t                       location,
-  SpvReflectResult*              p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetOutputVariable(const SpvReflectShaderModule* p_module, uint32_t location,
+                                                               SpvReflectResult* p_result) {
   return spvReflectGetOutputVariableByLocation(p_module, location, p_result);
 }
 
-const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableByLocation(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  uint32_t                      location,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableByLocation(const SpvReflectShaderModule* p_module,
+                                                                                   const char* entry_point, uint32_t location,
+                                                                                   SpvReflectResult* p_result) {
   if (location == INVALID_VALUE) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
@@ -4541,19 +5193,14 @@ const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableByLocati
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
 
-const SpvReflectInterfaceVariable* spvReflectGetOutputVariableBySemantic(
-  const SpvReflectShaderModule*  p_module,
-  const char*                    semantic,
-  SpvReflectResult*              p_result
-)
-{
+const SpvReflectInterfaceVariable* spvReflectGetOutputVariableBySemantic(const SpvReflectShaderModule* p_module,
+                                                                         const char* semantic, SpvReflectResult* p_result) {
   if (IsNull(semantic)) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
@@ -4577,19 +5224,15 @@ const SpvReflectInterfaceVariable* spvReflectGetOutputVariableBySemantic(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
 
-const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableBySemantic(
-  const SpvReflectShaderModule* p_module,
-  const char*                   entry_point,
-  const char*                   semantic,
-  SpvReflectResult*             p_result)
-{
+const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableBySemantic(const SpvReflectShaderModule* p_module,
+                                                                                   const char* entry_point, const char* semantic,
+                                                                                   SpvReflectResult* p_result) {
   if (IsNull(semantic)) {
     if (IsNotNull(p_result)) {
       *p_result = SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
@@ -4620,19 +5263,14 @@ const SpvReflectInterfaceVariable* spvReflectGetEntryPointOutputVariableBySemant
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_var)
-      ?  SPV_REFLECT_RESULT_SUCCESS
-      : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-        : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_var;
 }
 
-const SpvReflectBlockVariable* spvReflectGetPushConstantBlock(
-  const SpvReflectShaderModule* p_module,
-  uint32_t                      index,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectBlockVariable* spvReflectGetPushConstantBlock(const SpvReflectShaderModule* p_module, uint32_t index,
+                                                              SpvReflectResult* p_result) {
   const SpvReflectBlockVariable* p_push_constant = NULL;
   if (IsNotNull(p_module)) {
     if (index < p_module->push_constant_block_count) {
@@ -4641,30 +5279,21 @@ const SpvReflectBlockVariable* spvReflectGetPushConstantBlock(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_push_constant)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_push_constant;
 }
-const SpvReflectBlockVariable* spvReflectGetPushConstant(
-  const SpvReflectShaderModule* p_module,
-  uint32_t                      index,
-  SpvReflectResult*             p_result
-)
-{
+const SpvReflectBlockVariable* spvReflectGetPushConstant(const SpvReflectShaderModule* p_module, uint32_t index,
+                                                         SpvReflectResult* p_result) {
   return spvReflectGetPushConstantBlock(p_module, index, p_result);
 }
 
-const SpvReflectBlockVariable* spvReflectGetEntryPointPushConstantBlock(
-  const SpvReflectShaderModule*  p_module,
-  const char*                    entry_point,
-  SpvReflectResult*              p_result)
-{
+const SpvReflectBlockVariable* spvReflectGetEntryPointPushConstantBlock(const SpvReflectShaderModule* p_module,
+                                                                        const char* entry_point, SpvReflectResult* p_result) {
   const SpvReflectBlockVariable* p_push_constant = NULL;
   if (IsNotNull(p_module)) {
-    const SpvReflectEntryPoint* p_entry =
-        spvReflectGetEntryPoint(p_module, entry_point);
+    const SpvReflectEntryPoint* p_entry = spvReflectGetEntryPoint(p_module, entry_point);
     if (IsNull(p_entry)) {
       if (IsNotNull(p_result)) {
         *p_result = SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
@@ -4672,10 +5301,8 @@ const SpvReflectBlockVariable* spvReflectGetEntryPointPushConstantBlock(
       return NULL;
     }
     for (uint32_t i = 0; i < p_module->push_constant_block_count; ++i) {
-      bool found = SearchSortedUint32(
-        p_entry->used_push_constants,
-        p_entry->used_push_constant_count,
-        p_module->push_constant_blocks[i].spirv_id);
+      bool found = SearchSortedUint32(p_entry->used_push_constants, p_entry->used_push_constant_count,
+                                      p_module->push_constant_blocks[i].spirv_id);
       if (found) {
         p_push_constant = &p_module->push_constant_blocks[i];
         break;
@@ -4684,20 +5311,15 @@ const SpvReflectBlockVariable* spvReflectGetEntryPointPushConstantBlock(
   }
   if (IsNotNull(p_result)) {
     *p_result = IsNotNull(p_push_constant)
-        ?  SPV_REFLECT_RESULT_SUCCESS
-        : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER
-                            : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
+                    ? SPV_REFLECT_RESULT_SUCCESS
+                    : (IsNull(p_module) ? SPV_REFLECT_RESULT_ERROR_NULL_POINTER : SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND);
   }
   return p_push_constant;
 }
 
-SpvReflectResult spvReflectChangeDescriptorBindingNumbers(
-  SpvReflectShaderModule*            p_module,
-  const SpvReflectDescriptorBinding* p_binding,
-  uint32_t                           new_binding_number,
-  uint32_t                           new_set_binding
-)
-{
+SpvReflectResult spvReflectChangeDescriptorBindingNumbers(SpvReflectShaderModule* p_module,
+                                                          const SpvReflectDescriptorBinding* p_binding, uint32_t new_binding_number,
+                                                          uint32_t new_set_binding) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4707,7 +5329,7 @@ SpvReflectResult spvReflectChangeDescriptorBindingNumbers(
 
   SpvReflectDescriptorBinding* p_target_descriptor = NULL;
   for (uint32_t index = 0; index < p_module->descriptor_binding_count; ++index) {
-    if(&p_module->descriptor_bindings[index] == p_binding) {
+    if (&p_module->descriptor_bindings[index] == p_binding) {
       p_target_descriptor = &p_module->descriptor_bindings[index];
       break;
     }
@@ -4737,25 +5359,14 @@ SpvReflectResult spvReflectChangeDescriptorBindingNumbers(
   }
   return result;
 }
-SpvReflectResult spvReflectChangeDescriptorBindingNumber(
-  SpvReflectShaderModule*            p_module,
-  const SpvReflectDescriptorBinding* p_descriptor_binding,
-  uint32_t                           new_binding_number,
-  uint32_t                           optional_new_set_number
-)
-{
-  return spvReflectChangeDescriptorBindingNumbers(
-    p_module,p_descriptor_binding, 
-    new_binding_number, 
-    optional_new_set_number);
+SpvReflectResult spvReflectChangeDescriptorBindingNumber(SpvReflectShaderModule* p_module,
+                                                         const SpvReflectDescriptorBinding* p_descriptor_binding,
+                                                         uint32_t new_binding_number, uint32_t optional_new_set_number) {
+  return spvReflectChangeDescriptorBindingNumbers(p_module, p_descriptor_binding, new_binding_number, optional_new_set_number);
 }
 
-SpvReflectResult spvReflectChangeDescriptorSetNumber(
-  SpvReflectShaderModule*        p_module,
-  const SpvReflectDescriptorSet* p_set,
-  uint32_t                       new_set_number
-)
-{
+SpvReflectResult spvReflectChangeDescriptorSetNumber(SpvReflectShaderModule* p_module, const SpvReflectDescriptorSet* p_set,
+                                                     uint32_t new_set_number) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4791,12 +5402,8 @@ SpvReflectResult spvReflectChangeDescriptorSetNumber(
   return result;
 }
 
-static SpvReflectResult ChangeVariableLocation(
-  SpvReflectShaderModule*      p_module,
-  SpvReflectInterfaceVariable* p_variable,
-  uint32_t                     new_location
-)
-{
+static SpvReflectResult ChangeVariableLocation(SpvReflectShaderModule* p_module, SpvReflectInterfaceVariable* p_variable,
+                                               uint32_t new_location) {
   if (p_variable->word_offset.location > (p_module->_internal->spirv_word_count - 1)) {
     return SPV_REFLECT_RESULT_ERROR_RANGE_EXCEEDED;
   }
@@ -4806,12 +5413,8 @@ static SpvReflectResult ChangeVariableLocation(
   return SPV_REFLECT_RESULT_SUCCESS;
 }
 
-SpvReflectResult spvReflectChangeInputVariableLocation(
-  SpvReflectShaderModule*            p_module,
-  const SpvReflectInterfaceVariable* p_input_variable,
-  uint32_t                           new_location
-)
-{
+SpvReflectResult spvReflectChangeInputVariableLocation(SpvReflectShaderModule* p_module,
+                                                       const SpvReflectInterfaceVariable* p_input_variable, uint32_t new_location) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4819,19 +5422,16 @@ SpvReflectResult spvReflectChangeInputVariableLocation(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
   for (uint32_t index = 0; index < p_module->input_variable_count; ++index) {
-    if(p_module->input_variables[index] == p_input_variable) {
+    if (p_module->input_variables[index] == p_input_variable) {
       return ChangeVariableLocation(p_module, p_module->input_variables[index], new_location);
     }
   }
   return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
 }
 
-SpvReflectResult spvReflectChangeOutputVariableLocation(
-  SpvReflectShaderModule*             p_module,
-  const SpvReflectInterfaceVariable*  p_output_variable,
-  uint32_t                            new_location
-)
-{
+SpvReflectResult spvReflectChangeOutputVariableLocation(SpvReflectShaderModule* p_module,
+                                                        const SpvReflectInterfaceVariable* p_output_variable,
+                                                        uint32_t new_location) {
   if (IsNull(p_module)) {
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
@@ -4839,25 +5439,44 @@ SpvReflectResult spvReflectChangeOutputVariableLocation(
     return SPV_REFLECT_RESULT_ERROR_NULL_POINTER;
   }
   for (uint32_t index = 0; index < p_module->output_variable_count; ++index) {
-    if(p_module->output_variables[index] == p_output_variable) {
+    if (p_module->output_variables[index] == p_output_variable) {
       return ChangeVariableLocation(p_module, p_module->output_variables[index], new_location);
     }
   }
   return SPV_REFLECT_RESULT_ERROR_ELEMENT_NOT_FOUND;
 }
 
-const char* spvReflectSourceLanguage(SpvSourceLanguage source_lang)
-{
+const char* spvReflectSourceLanguage(SpvSourceLanguage source_lang) {
   switch (source_lang) {
-    case SpvSourceLanguageUnknown    : return "Unknown";
-    case SpvSourceLanguageESSL       : return "ESSL";
-    case SpvSourceLanguageGLSL       : return "GLSL";
-    case SpvSourceLanguageOpenCL_C   : return "OpenCL_C";
-    case SpvSourceLanguageOpenCL_CPP : return "OpenCL_CPP";
-    case SpvSourceLanguageHLSL       : return "HLSL";
-
-    case SpvSourceLanguageMax:
+    case SpvSourceLanguageESSL:
+      return "ESSL";
+    case SpvSourceLanguageGLSL:
+      return "GLSL";
+    case SpvSourceLanguageOpenCL_C:
+      return "OpenCL_C";
+    case SpvSourceLanguageOpenCL_CPP:
+      return "OpenCL_CPP";
+    case SpvSourceLanguageHLSL:
+      return "HLSL";
+    case SpvSourceLanguageCPP_for_OpenCL:
+      return "CPP_for_OpenCL";
+    case SpvSourceLanguageSYCL:
+      return "SYCL";
+    case SpvSourceLanguageHERO_C:
+      return "Hero C";
+    case SpvSourceLanguageNZSL:
+      return "NZSL";
+    default:
       break;
   }
-  return "";
+  // The source language is SpvSourceLanguageUnknown, SpvSourceLanguageMax, or
+  // some other value that does not correspond to a knonwn language.
+  return "Unknown";
+}
+
+const char* spvReflectBlockVariableTypeName(const SpvReflectBlockVariable* p_var) {
+  if (p_var == NULL) {
+    return NULL;
+  }
+  return p_var->type_description->type_name;
 }
diff --git a/WickedEngine/Utility/spirv_reflect.h b/WickedEngine/Utility/spirv_reflect.h
index 12ef2b1e3..9a42f14ee 100644
--- a/WickedEngine/Utility/spirv_reflect.h
+++ b/WickedEngine/Utility/spirv_reflect.h
@@ -22,6 +22,7 @@ VERSION HISTORY
 
 */
 
+// clang-format off
 /*!
 
  @file spirv_reflect.h
@@ -134,6 +135,9 @@ NOTE: HLSL row_major and column_major decorations are reversed
       SPIRV-Reflect reads the data as is and does not make any
       attempt to correct it to match what's in the source.
 
+      The Patch, PerVertex, and PerTask are used for Interface
+      variables that can have array
+
 */
 typedef enum SpvReflectDecorationFlagBits {
   SPV_REFLECT_DECORATION_NONE                   = 0x00000000,
@@ -147,10 +151,59 @@ typedef enum SpvReflectDecorationFlagBits {
   SPV_REFLECT_DECORATION_NON_WRITABLE           = 0x00000080,
   SPV_REFLECT_DECORATION_RELAXED_PRECISION      = 0x00000100,
   SPV_REFLECT_DECORATION_NON_READABLE           = 0x00000200,
+  SPV_REFLECT_DECORATION_PATCH                  = 0x00000400,
+  SPV_REFLECT_DECORATION_PER_VERTEX             = 0x00000800,
+  SPV_REFLECT_DECORATION_PER_TASK               = 0x00001000,
+  SPV_REFLECT_DECORATION_WEIGHT_TEXTURE         = 0x00002000,
+  SPV_REFLECT_DECORATION_BLOCK_MATCH_TEXTURE    = 0x00004000,
 } SpvReflectDecorationFlagBits;
 
 typedef uint32_t SpvReflectDecorationFlags;
 
+// Based of SPV_GOOGLE_user_type
+typedef enum SpvReflectUserType {
+  SPV_REFLECT_USER_TYPE_INVALID = 0,
+  SPV_REFLECT_USER_TYPE_CBUFFER,
+  SPV_REFLECT_USER_TYPE_TBUFFER,
+  SPV_REFLECT_USER_TYPE_APPEND_STRUCTURED_BUFFER,
+  SPV_REFLECT_USER_TYPE_BUFFER,
+  SPV_REFLECT_USER_TYPE_BYTE_ADDRESS_BUFFER,
+  SPV_REFLECT_USER_TYPE_CONSTANT_BUFFER,
+  SPV_REFLECT_USER_TYPE_CONSUME_STRUCTURED_BUFFER,
+  SPV_REFLECT_USER_TYPE_INPUT_PATCH,
+  SPV_REFLECT_USER_TYPE_OUTPUT_PATCH,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BUFFER,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_BYTE_ADDRESS_BUFFER,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_STRUCTURED_BUFFER,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_1D_ARRAY,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_2D_ARRAY,
+  SPV_REFLECT_USER_TYPE_RASTERIZER_ORDERED_TEXTURE_3D,
+  SPV_REFLECT_USER_TYPE_RAYTRACING_ACCELERATION_STRUCTURE,
+  SPV_REFLECT_USER_TYPE_RW_BUFFER,
+  SPV_REFLECT_USER_TYPE_RW_BYTE_ADDRESS_BUFFER,
+  SPV_REFLECT_USER_TYPE_RW_STRUCTURED_BUFFER,
+  SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D,
+  SPV_REFLECT_USER_TYPE_RW_TEXTURE_1D_ARRAY,
+  SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D,
+  SPV_REFLECT_USER_TYPE_RW_TEXTURE_2D_ARRAY,
+  SPV_REFLECT_USER_TYPE_RW_TEXTURE_3D,
+  SPV_REFLECT_USER_TYPE_STRUCTURED_BUFFER,
+  SPV_REFLECT_USER_TYPE_SUBPASS_INPUT,
+  SPV_REFLECT_USER_TYPE_SUBPASS_INPUT_MS,
+  SPV_REFLECT_USER_TYPE_TEXTURE_1D,
+  SPV_REFLECT_USER_TYPE_TEXTURE_1D_ARRAY,
+  SPV_REFLECT_USER_TYPE_TEXTURE_2D,
+  SPV_REFLECT_USER_TYPE_TEXTURE_2D_ARRAY,
+  SPV_REFLECT_USER_TYPE_TEXTURE_2DMS,
+  SPV_REFLECT_USER_TYPE_TEXTURE_2DMS_ARRAY,
+  SPV_REFLECT_USER_TYPE_TEXTURE_3D,
+  SPV_REFLECT_USER_TYPE_TEXTURE_BUFFER,
+  SPV_REFLECT_USER_TYPE_TEXTURE_CUBE,
+  SPV_REFLECT_USER_TYPE_TEXTURE_CUBE_ARRAY,
+} SpvReflectUserType;
+
 /*! @enum SpvReflectResourceType
 
 */
@@ -211,6 +264,8 @@ typedef enum SpvReflectFormat {
 enum SpvReflectVariableFlagBits{
   SPV_REFLECT_VARIABLE_FLAGS_NONE   = 0x00000000,
   SPV_REFLECT_VARIABLE_FLAGS_UNUSED = 0x00000001,
+  // If variable points to a copy of the PhysicalStorageBuffer struct
+  SPV_REFLECT_VARIABLE_FLAGS_PHYSICAL_POINTER_COPY = 0x00000002,
 };
 
 typedef uint32_t SpvReflectVariableFlags;
@@ -310,7 +365,6 @@ typedef struct SpvReflectImageTraits {
 
 typedef enum SpvReflectArrayDimType {
   SPV_REFLECT_ARRAY_DIM_RUNTIME       = 0,         // OpTypeRuntimeArray
-  SPV_REFLECT_ARRAY_DIM_SPEC_CONSTANT = 0xFFFFFFFF // specialization constant
 } SpvReflectArrayDimType;
 
 typedef struct SpvReflectArrayTraits {
@@ -353,6 +407,10 @@ typedef struct SpvReflectTypeDescription {
   // this gives access to the OpTypeStruct
   struct SpvReflectTypeDescription* struct_type_description;
 
+  // Some pointers to SpvReflectTypeDescription are really
+  // just copies of another reference to the same OpType
+  uint32_t                          copied;
+
   // @deprecated use struct_type_description instead
   uint32_t                          member_count;
   // @deprecated use struct_type_description instead
@@ -436,6 +494,8 @@ typedef struct SpvReflectDescriptorBinding {
   uint32_t                            accessed;
   uint32_t                            uav_counter_id;
   struct SpvReflectDescriptorBinding* uav_counter_binding;
+  uint32_t                            byte_address_buffer_offset_count;
+  uint32_t*                           byte_address_buffer_offsets;
 
   SpvReflectTypeDescription*          type_description;
 
@@ -445,6 +505,8 @@ typedef struct SpvReflectDescriptorBinding {
   } word_offset;
 
   SpvReflectDecorationFlags           decoration_flags;
+  // Requires SPV_GOOGLE_user_type
+  SpvReflectUserType                  user_type;
 } SpvReflectDescriptorBinding;
 
 /*! @struct SpvReflectDescriptorSet
@@ -456,6 +518,10 @@ typedef struct SpvReflectDescriptorSet {
   SpvReflectDescriptorBinding**     bindings;
 } SpvReflectDescriptorSet;
 
+typedef enum SpvReflectExecutionModeValue {
+  SPV_REFLECT_EXECUTION_MODE_SPEC_CONSTANT = 0xFFFFFFFF // specialization constant
+} SpvReflectExecutionModeValue;
+
 /*! @struct SpvReflectEntryPoint
 
  */
@@ -501,6 +567,16 @@ typedef struct SpvReflectCapability {
   uint32_t                          word_offset;
 } SpvReflectCapability;
 
+
+/*! @struct SpvReflectSpecId
+
+*/
+typedef struct SpvReflectSpecializationConstant {
+  uint32_t spirv_id;
+  uint32_t constant_id;
+  const char* name;
+} SpvReflectSpecializationConstant;
+
 /*! @struct SpvReflectShaderModule
 
 */
@@ -530,6 +606,8 @@ typedef struct SpvReflectShaderModule {
   SpvReflectInterfaceVariable*      interface_variables;                              // Uses value(s) from first entry point
   uint32_t                          push_constant_block_count;                        // Uses value(s) from first entry point
   SpvReflectBlockVariable*          push_constant_blocks;                             // Uses value(s) from first entry point
+  uint32_t                          spec_constant_count;                              // Uses value(s) from first entry point
+  SpvReflectSpecializationConstant* spec_constants;                                   // Uses value(s) from first entry point
 
   struct Internal {
     SpvReflectModuleFlags           module_flags;
@@ -941,6 +1019,25 @@ SpvReflectResult spvReflectEnumerateEntryPointPushConstantBlocks(
 );
 
 
+/*! @fn spvReflectEnumerateSpecializationConstants
+ @param  p_module      Pointer to an instance of SpvReflectShaderModule.
+ @param  p_count       If pp_blocks is NULL, the module's specialization constant
+                       count will be stored here. If pp_blocks is not NULL, *p_count
+                       must contain the module's specialization constant count.
+ @param  pp_constants  If NULL, the module's specialization constant count
+                       will be written to *p_count. If non-NULL, pp_blocks must
+                       point to an array with *p_count entries, where pointers to
+                       the module's specialization constant blocks will be written.
+                       The caller must not free the  variables written to this array.
+ @return               If successful, returns SPV_REFLECT_RESULT_SUCCESS.
+                       Otherwise, the error code indicates the cause of the failure.
+*/
+SpvReflectResult spvReflectEnumerateSpecializationConstants(
+  const SpvReflectShaderModule*      p_module,
+  uint32_t*                          p_count,
+  SpvReflectSpecializationConstant** pp_constants
+);
+
 /*! @fn spvReflectGetDescriptorBinding
 
  @param  p_module        Pointer to an instance of SpvReflectShaderModule.
@@ -1531,6 +1628,7 @@ public:
   SpvReflectResult  EnumeratePushConstants(uint32_t* p_count, SpvReflectBlockVariable** pp_blocks) const {
     return EnumeratePushConstantBlocks(p_count, pp_blocks);
   }
+  SpvReflectResult  EnumerateSpecializationConstants(uint32_t* p_count, SpvReflectSpecializationConstant** pp_constants) const;
 
   const SpvReflectDescriptorBinding*  GetDescriptorBinding(uint32_t binding_number, uint32_t set_number, SpvReflectResult* p_result = nullptr) const;
   const SpvReflectDescriptorBinding*  GetEntryPointDescriptorBinding(const char* entry_point, uint32_t binding_number, uint32_t set_number, SpvReflectResult* p_result = nullptr) const;
@@ -1978,6 +2076,24 @@ inline SpvReflectResult ShaderModule::EnumeratePushConstantBlocks(
   return m_result;
 }
 
+/*! @fn EnumerateSpecializationConstants
+  @param  p_count
+  @param  pp_constants
+  @return
+*/
+inline SpvReflectResult ShaderModule::EnumerateSpecializationConstants(
+    uint32_t*                          p_count,
+    SpvReflectSpecializationConstant** pp_constants
+) const
+{
+  m_result = spvReflectEnumerateSpecializationConstants(
+    &m_module,
+    p_count,
+    pp_constants
+  );
+  return m_result;
+}
+
 /*! @fn EnumerateEntryPointPushConstantBlocks
 
   @param  entry_point
@@ -2327,3 +2443,5 @@ inline SpvReflectResult ShaderModule::ChangeOutputVariableLocation(
 } // namespace spv_reflect
 #endif // defined(__cplusplus) && !defined(SPIRV_REFLECT_DISABLE_CPP_WRAPPER)
 #endif // SPIRV_REFLECT_H
+
+// clang-format on
diff --git a/WickedEngine/Utility/vk_mem_alloc.h b/WickedEngine/Utility/vk_mem_alloc.h
index f65aae059..0f4619d3a 100644
--- a/WickedEngine/Utility/vk_mem_alloc.h
+++ b/WickedEngine/Utility/vk_mem_alloc.h
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -25,14 +25,17 @@
 
 /** \mainpage Vulkan Memory Allocator
 
-<b>Version 3.1.0-development</b>
+<b>Version 3.1.0</b>
 
-Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved. \n
-License: MIT
+Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved. \n
+License: MIT \n
+See also: [product page on GPUOpen](https://gpuopen.com/gaming-product/vulkan-memory-allocator/),
+[repository on GitHub](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
 
-<b>API documentation divided into groups:</b> [Modules](modules.html)
 
-\section main_table_of_contents Table of contents
+<b>API documentation divided into groups:</b> [Topics](topics.html)
+
+<b>General documentation chapters:</b>
 
 - <b>User guide</b>
   - \subpage quick_start
@@ -46,6 +49,7 @@ License: MIT
     - [Custom memory pools](@ref choosing_memory_type_custom_memory_pools)
     - [Dedicated allocations](@ref choosing_memory_type_dedicated_allocations)
   - \subpage memory_mapping
+    - [Copy functions](@ref memory_mapping_copy_functions)
     - [Mapping functions](@ref memory_mapping_mapping_functions)
     - [Persistently mapped memory](@ref memory_mapping_persistently_mapped_memory)
     - [Cache flush and invalidate](@ref memory_mapping_cache_control)
@@ -55,6 +59,7 @@ License: MIT
   - \subpage resource_aliasing
   - \subpage custom_memory_pools
     - [Choosing memory type index](@ref custom_memory_pools_MemTypeIndex)
+    - [When not to use custom pools](@ref custom_memory_pools_when_not_use)
     - [Linear allocation algorithm](@ref linear_algorithm)
       - [Free-at-once](@ref linear_algorithm_free_at_once)
       - [Stack](@ref linear_algorithm_stack)
@@ -72,7 +77,8 @@ License: MIT
     - [Memory initialization](@ref debugging_memory_usage_initialization)
     - [Margins](@ref debugging_memory_usage_margins)
     - [Corruption detection](@ref debugging_memory_usage_corruption_detection)
-  - \subpage opengl_interop
+    - [Leak detection features](@ref debugging_memory_usage_leak_detection)
+  - \subpage other_api_interop
 - \subpage usage_patterns
     - [GPU-only resource](@ref usage_patterns_gpu_only)
     - [Staging copy for upload](@ref usage_patterns_staging_copy_upload)
@@ -96,11 +102,6 @@ License: MIT
   - [Allocation algorithm](@ref general_considerations_allocation_algorithm)
   - [Features not supported](@ref general_considerations_features_not_supported)
 
-\section main_see_also See also
-
-- [**Product page on GPUOpen**](https://gpuopen.com/gaming-product/vulkan-memory-allocator/)
-- [**Source repository on GitHub**](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
-
 \defgroup group_init Library initialization
 
 \brief API elements related to the initialization and management of the entire library, especially #VmaAllocator object.
@@ -126,7 +127,7 @@ See documentation chapter: \ref statistics.
 extern "C" {
 #endif
 
-#ifndef VULKAN_H_
+#if !defined(VULKAN_H_)
 #include <vulkan/vulkan.h>
 #endif
 
@@ -213,6 +214,25 @@ extern "C" {
     #endif
 #endif
 
+// Defined to 1 when VK_KHR_maintenance4 device extension is defined in Vulkan headers.
+#if !defined(VMA_KHR_MAINTENANCE4)
+    #if VK_KHR_maintenance4
+        #define VMA_KHR_MAINTENANCE4 1
+    #else
+        #define VMA_KHR_MAINTENANCE4 0
+    #endif
+#endif
+
+// Defined to 1 when VK_KHR_maintenance5 device extension is defined in Vulkan headers.
+#if !defined(VMA_KHR_MAINTENANCE5)
+    #if VK_KHR_maintenance5
+        #define VMA_KHR_MAINTENANCE5 1
+    #else
+        #define VMA_KHR_MAINTENANCE5 0
+    #endif
+#endif
+
+
 // Defined to 1 when VK_KHR_external_memory device extension is defined in Vulkan headers.
 #if !defined(VMA_EXTERNAL_MEMORY)
     #if VK_KHR_external_memory
@@ -426,6 +446,20 @@ typedef enum VmaAllocatorCreateFlagBits
     For more details, see the documentation of the VK_EXT_memory_priority extension.
     */
     VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT = 0x00000040,
+    /**
+    Enables usage of VK_KHR_maintenance4 extension in the library.
+
+    You may set this flag only if you found available and enabled this device extension,
+    while creating Vulkan device passed as VmaAllocatorCreateInfo::device.
+    */
+    VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT = 0x00000080,
+    /**
+    Enables usage of VK_KHR_maintenance5 extension in the library.
+
+    You should set this flag if you found available and enabled this device extension,
+    while creating Vulkan device passed as VmaAllocatorCreateInfo::device.
+    */
+    VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT = 0x00000100,
 
     VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VmaAllocatorCreateFlagBits;
@@ -527,6 +561,9 @@ typedef enum VmaAllocationCreateFlagBits
     /** \brief Set this flag if the allocation should have its own memory block.
 
     Use it for special, big resources, like fullscreen images used as attachments.
+
+    If you use this flag while creating a buffer or an image, `VkMemoryDedicatedAllocateInfo`
+    structure is applied if possible.
     */
     VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
 
@@ -608,7 +645,7 @@ typedef enum VmaAllocationCreateFlagBits
       This includes allocations created in \ref custom_memory_pools.
 
     Declares that mapped memory can be read, written, and accessed in random order,
-    so a `HOST_CACHED` memory type is required.
+    so a `HOST_CACHED` memory type is preferred.
     */
     VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT = 0x00000800,
     /**
@@ -890,7 +927,7 @@ Use it as a unique identifier to virtual allocation within the single block.
 
 Use value `VK_NULL_HANDLE` to represent a null/invalid allocation.
 */
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VmaVirtualAllocation);
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VmaVirtualAllocation)
 
 /** @} */
 
@@ -989,13 +1026,14 @@ typedef struct VmaVulkanFunctions
     PFN_vkBindImageMemory2KHR VMA_NULLABLE vkBindImageMemory2KHR;
 #endif
 #if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
+    /// Fetch from "vkGetPhysicalDeviceMemoryProperties2" on Vulkan >= 1.1, but you can also fetch it from "vkGetPhysicalDeviceMemoryProperties2KHR" if you enabled extension VK_KHR_get_physical_device_properties2.
     PFN_vkGetPhysicalDeviceMemoryProperties2KHR VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties2KHR;
 #endif
-#if VMA_VULKAN_VERSION >= 1003000
+#if VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
     /// Fetch from "vkGetDeviceBufferMemoryRequirements" on Vulkan >= 1.3, but you can also fetch it from "vkGetDeviceBufferMemoryRequirementsKHR" if you enabled extension VK_KHR_maintenance4.
-    PFN_vkGetDeviceBufferMemoryRequirements VMA_NULLABLE vkGetDeviceBufferMemoryRequirements;
+    PFN_vkGetDeviceBufferMemoryRequirementsKHR VMA_NULLABLE vkGetDeviceBufferMemoryRequirements;
     /// Fetch from "vkGetDeviceImageMemoryRequirements" on Vulkan >= 1.3, but you can also fetch it from "vkGetDeviceImageMemoryRequirementsKHR" if you enabled extension VK_KHR_maintenance4.
-    PFN_vkGetDeviceImageMemoryRequirements VMA_NULLABLE vkGetDeviceImageMemoryRequirements;
+    PFN_vkGetDeviceImageMemoryRequirementsKHR VMA_NULLABLE vkGetDeviceImageMemoryRequirements;
 #endif
 } VmaVulkanFunctions;
 
@@ -1055,13 +1093,15 @@ typedef struct VmaAllocatorCreateInfo
     Starting from version 3.0.0 this member is no longer optional, it must be set!
     */
     VkInstance VMA_NOT_NULL instance;
-    /** \brief Optional. The highest version of Vulkan that the application is designed to use.
+    /** \brief Optional. Vulkan version that the application uses.
 
     It must be a value in the format as created by macro `VK_MAKE_VERSION` or a constant like: `VK_API_VERSION_1_1`, `VK_API_VERSION_1_0`.
     The patch version number specified is ignored. Only the major and minor versions are considered.
-    It must be less or equal (preferably equal) to value as passed to `vkCreateInstance` as `VkApplicationInfo::apiVersion`.
     Only versions 1.0, 1.1, 1.2, 1.3 are supported by the current implementation.
     Leaving it initialized to zero is equivalent to `VK_API_VERSION_1_0`.
+    It must match the Vulkan version used by the application and supported on the selected physical device,
+    so it must be no higher than `VkApplicationInfo::apiVersion` passed to `vkCreateInstance`
+    and no higher than `VkPhysicalDeviceProperties::apiVersion` found on the physical device used.
     */
     uint32_t vulkanApiVersion;
 #if VMA_EXTERNAL_MEMORY
@@ -2128,7 +2168,7 @@ For more information, see documentation of vmaFlushAllocation().
 \param allocator
 \param allocationCount
 \param allocations
-\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
+\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all offsets are zero.
 \param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
 
 This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
@@ -2149,7 +2189,7 @@ For more information, see documentation of vmaInvalidateAllocation().
 \param allocator
 \param allocationCount
 \param allocations
-\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
+\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all offsets are zero.
 \param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
 
 This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if it is
@@ -2162,6 +2202,61 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
     const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) offsets,
     const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) sizes);
 
+/** \brief Maps the allocation temporarily if needed, copies data from specified host pointer to it, and flushes the memory from the host caches if needed.
+
+\param allocator
+\param pSrcHostPointer Pointer to the host data that become source of the copy.
+\param dstAllocation   Handle to the allocation that becomes destination of the copy.
+\param dstAllocationLocalOffset  Offset within `dstAllocation` where to write copied data, in bytes.
+\param size            Number of bytes to copy.
+
+This is a convenience function that allows to copy data from a host pointer to an allocation easily.
+Same behavior can be achieved by calling vmaMapMemory(), `memcpy()`, vmaUnmapMemory(), vmaFlushAllocation().
+
+This function can be called only for allocations created in a memory type that has `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` flag.
+It can be ensured e.g. by using #VMA_MEMORY_USAGE_AUTO and #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or
+#VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
+Otherwise, the function will fail and generate a Validation Layers error.
+
+`dstAllocationLocalOffset` is relative to the contents of given `dstAllocation`.
+If you mean whole allocation, you should pass 0.
+Do not pass allocation's offset within device memory block this parameter!
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCopyMemoryToAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const void* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(size) pSrcHostPointer,
+    VmaAllocation VMA_NOT_NULL dstAllocation,
+    VkDeviceSize dstAllocationLocalOffset,
+    VkDeviceSize size);
+
+/** \brief Invalidates memory in the host caches if needed, maps the allocation temporarily if needed, and copies data from it to a specified host pointer.
+
+\param allocator
+\param srcAllocation   Handle to the allocation that becomes source of the copy.
+\param srcAllocationLocalOffset  Offset within `srcAllocation` where to read copied data, in bytes.
+\param pDstHostPointer Pointer to the host memory that become destination of the copy.
+\param size            Number of bytes to copy.
+
+This is a convenience function that allows to copy data from an allocation to a host pointer easily.
+Same behavior can be achieved by calling vmaInvalidateAllocation(), vmaMapMemory(), `memcpy()`, vmaUnmapMemory().
+
+This function should be called only for allocations created in a memory type that has `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`
+and `VK_MEMORY_PROPERTY_HOST_CACHED_BIT` flag.
+It can be ensured e.g. by using #VMA_MEMORY_USAGE_AUTO and #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
+Otherwise, the function may fail and generate a Validation Layers error.
+It may also work very slowly when reading from an uncached memory.
+
+`srcAllocationLocalOffset` is relative to the contents of given `srcAllocation`.
+If you mean whole allocation, you should pass 0.
+Do not pass allocation's offset within device memory block as this parameter!
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCopyAllocationToMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL srcAllocation,
+    VkDeviceSize srcAllocationLocalOffset,
+    void* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(size) pDstHostPointer,
+    VkDeviceSize size);
+
 /** \brief Checks magic number in margins around all allocations in given memory types (in both default and custom pools) in search for corruptions.
 
 \param allocator
@@ -2663,6 +2758,7 @@ VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
+#include <cinttypes>
 #include <utility>
 #include <type_traits>
 
@@ -2678,7 +2774,7 @@ VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
     #include <intrin.h> // For functions like __popcnt, _BitScanForward etc.
 #endif
 #if VMA_CPP20
-    #include <bit> // For std::popcount
+    #include <bit>
 #endif
 
 #if VMA_STATS_STRING_ENABLED
@@ -2752,7 +2848,7 @@ remove them if not needed.
 */
 #if !defined(VMA_CONFIGURATION_USER_INCLUDES_H)
     #include <cassert> // for assert
-    #include <algorithm> // for min, max
+    #include <algorithm> // for min, max, swap
     #include <mutex>
 #else
     #include VMA_CONFIGURATION_USER_INCLUDES_H
@@ -2917,10 +3013,6 @@ static void vma_aligned_free(void* VMA_NULLABLE ptr)
    #define VMA_MAX(v1, v2)    ((std::max)((v1), (v2)))
 #endif
 
-#ifndef VMA_SWAP
-   #define VMA_SWAP(v1, v2)   std::swap((v1), (v2))
-#endif
-
 #ifndef VMA_SORT
    #define VMA_SORT(beg, end, cmp)  std::sort(beg, end, cmp)
 #endif
@@ -2939,6 +3031,10 @@ static void vma_aligned_free(void* VMA_NULLABLE ptr)
     #define VMA_DEBUG_LOG(str)   VMA_DEBUG_LOG_FORMAT("%s", (str))
 #endif
 
+#ifndef VMA_LEAK_LOG_FORMAT
+    #define VMA_LEAK_LOG_FORMAT(format, ...)   VMA_DEBUG_LOG_FORMAT(format, __VA_ARGS__)
+#endif
+
 #ifndef VMA_CLASS_NO_COPY
     #define VMA_CLASS_NO_COPY(className) \
         private: \
@@ -2958,11 +3054,11 @@ static void vma_aligned_free(void* VMA_NULLABLE ptr)
 #if VMA_STATS_STRING_ENABLED
     static inline void VmaUint32ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint32_t num)
     {
-        snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
+        snprintf(outStr, strLen, "%" PRIu32, num);
     }
     static inline void VmaUint64ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint64_t num)
     {
-        snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
+        snprintf(outStr, strLen, "%" PRIu64, num);
     }
     static inline void VmaPtrToStr(char* VMA_NOT_NULL outStr, size_t strLen, const void* ptr)
     {
@@ -3256,17 +3352,6 @@ class VmaList;
 template<typename ItemTypeTraits>
 class VmaIntrusiveLinkedList;
 
-// Unused in this version
-#if 0
-template<typename T1, typename T2>
-struct VmaPair;
-template<typename FirstT, typename SecondT>
-struct VmaPairFirstLess;
-
-template<typename KeyT, typename ValueT>
-class VmaMap;
-#endif
-
 #if VMA_STATS_STRING_ENABLED
 class VmaStringBuilder;
 class VmaJsonWriter;
@@ -3306,7 +3391,7 @@ class VmaAllocationObjectAllocator;
 /*
 Returns number of bits set to 1 in (v).
 
-On specific platforms and compilers you can use instrinsics like:
+On specific platforms and compilers you can use intrinsics like:
 
 Visual Studio:
     return __popcnt(v);
@@ -3337,6 +3422,10 @@ static inline uint8_t VmaBitScanLSB(uint64_t mask)
     if (_BitScanForward64(&pos, mask))
         return static_cast<uint8_t>(pos);
     return UINT8_MAX;
+#elif VMA_CPP20
+    if(mask)
+        return static_cast<uint8_t>(std::countr_zero(mask));
+    return UINT8_MAX;
 #elif defined __GNUC__ || defined __clang__
     return static_cast<uint8_t>(__builtin_ffsll(mask)) - 1U;
 #else
@@ -3359,6 +3448,10 @@ static inline uint8_t VmaBitScanLSB(uint32_t mask)
     if (_BitScanForward(&pos, mask))
         return static_cast<uint8_t>(pos);
     return UINT8_MAX;
+#elif VMA_CPP20
+    if(mask)
+        return static_cast<uint8_t>(std::countr_zero(mask));
+    return UINT8_MAX;
 #elif defined __GNUC__ || defined __clang__
     return static_cast<uint8_t>(__builtin_ffs(mask)) - 1U;
 #else
@@ -3380,6 +3473,9 @@ static inline uint8_t VmaBitScanMSB(uint64_t mask)
     unsigned long pos;
     if (_BitScanReverse64(&pos, mask))
         return static_cast<uint8_t>(pos);
+#elif VMA_CPP20
+    if(mask)
+        return 63 - static_cast<uint8_t>(std::countl_zero(mask));
 #elif defined __GNUC__ || defined __clang__
     if (mask)
         return 63 - static_cast<uint8_t>(__builtin_clzll(mask));
@@ -3402,6 +3498,9 @@ static inline uint8_t VmaBitScanMSB(uint32_t mask)
     unsigned long pos;
     if (_BitScanReverse(&pos, mask))
         return static_cast<uint8_t>(pos);
+#elif VMA_CPP20
+    if(mask)
+        return 31 - static_cast<uint8_t>(std::countl_zero(mask));
 #elif defined __GNUC__ || defined __clang__
     if (mask)
         return 31 - static_cast<uint8_t>(__builtin_clz(mask));
@@ -3549,7 +3648,7 @@ static inline bool VmaIsBufferImageGranularityConflict(
 {
     if (suballocType1 > suballocType2)
     {
-        VMA_SWAP(suballocType1, suballocType2);
+        std::swap(suballocType1, suballocType2);
     }
 
     switch (suballocType1)
@@ -3694,13 +3793,95 @@ static inline void VmaPnextChainPushFront(MainT* mainStruct, NewT* newStruct)
     newStruct->pNext = mainStruct->pNext;
     mainStruct->pNext = newStruct;
 }
+// Finds structure with s->sType == sType in mainStruct->pNext chain.
+// Returns pointer to it. If not found, returns null.
+template<typename FindT, typename MainT>
+static inline const FindT* VmaPnextChainFind(const MainT* mainStruct, VkStructureType sType)
+{
+    for(const VkBaseInStructure* s = (const VkBaseInStructure*)mainStruct->pNext;
+        s != VMA_NULL; s = s->pNext)
+    {
+        if(s->sType == sType)
+        {
+            return (const FindT*)s;
+        }
+    }
+    return VMA_NULL;
+}
+
+// An abstraction over buffer or image `usage` flags, depending on available extensions.
+struct VmaBufferImageUsage
+{
+#if VMA_KHR_MAINTENANCE5
+    typedef uint64_t BaseType; // VkFlags64
+#else
+    typedef uint32_t BaseType; // VkFlags32
+#endif
+
+    static const VmaBufferImageUsage UNKNOWN;
+
+    BaseType Value;
+
+    VmaBufferImageUsage() { *this = UNKNOWN; }
+    explicit VmaBufferImageUsage(BaseType usage) : Value(usage) { }
+    VmaBufferImageUsage(const VkBufferCreateInfo &createInfo, bool useKhrMaintenance5);
+    explicit VmaBufferImageUsage(const VkImageCreateInfo &createInfo);
+
+    bool operator==(const VmaBufferImageUsage& rhs) const { return Value == rhs.Value; }
+    bool operator!=(const VmaBufferImageUsage& rhs) const { return Value != rhs.Value; }
+
+    bool Contains(BaseType flag) const { return (Value & flag) != 0; }
+    bool ContainsDeviceAccess() const
+    {
+        // This relies on values of VK_IMAGE_USAGE_TRANSFER* being the same as VK_BUFFER_IMAGE_TRANSFER*.
+        return (Value & ~BaseType(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) != 0;
+    }
+};
+
+const VmaBufferImageUsage VmaBufferImageUsage::UNKNOWN = VmaBufferImageUsage(0);
+
+static void swap(VmaBufferImageUsage& lhs, VmaBufferImageUsage& rhs) noexcept
+{
+    using std::swap;
+    swap(lhs.Value, rhs.Value);
+}
+
+VmaBufferImageUsage::VmaBufferImageUsage(const VkBufferCreateInfo &createInfo,
+    bool useKhrMaintenance5)
+{
+#if VMA_KHR_MAINTENANCE5
+    if(useKhrMaintenance5)
+    {
+        // If VkBufferCreateInfo::pNext chain contains VkBufferUsageFlags2CreateInfoKHR,
+        // take usage from it and ignore VkBufferCreateInfo::usage, per specification
+        // of the VK_KHR_maintenance5 extension.
+        const VkBufferUsageFlags2CreateInfoKHR* const usageFlags2 =
+            VmaPnextChainFind<VkBufferUsageFlags2CreateInfoKHR>(&createInfo, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR);
+        if(usageFlags2)
+        {
+            this->Value = usageFlags2->usage;
+            return;
+        }
+    }
+#endif
+
+    this->Value = (BaseType)createInfo.usage;
+}
+
+VmaBufferImageUsage::VmaBufferImageUsage(const VkImageCreateInfo &createInfo)
+{
+    // Maybe in the future there will be VK_KHR_maintenanceN extension with structure
+    // VkImageUsageFlags2CreateInfoKHR, like the one for buffers...
+
+    this->Value = (BaseType)createInfo.usage;
+}
 
 // This is the main algorithm that guides the selection of a memory type best for an allocation -
 // converts usage to required/preferred/not preferred flags.
 static bool FindMemoryPreferences(
     bool isIntegratedGPU,
     const VmaAllocationCreateInfo& allocCreateInfo,
-    VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
+    VmaBufferImageUsage bufImgUsage,
     VkMemoryPropertyFlags& outRequiredFlags,
     VkMemoryPropertyFlags& outPreferredFlags,
     VkMemoryPropertyFlags& outNotPreferredFlags)
@@ -3743,13 +3924,14 @@ static bool FindMemoryPreferences(
     case VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE:
     case VMA_MEMORY_USAGE_AUTO_PREFER_HOST:
     {
-        if(bufImgUsage == UINT32_MAX)
+        if(bufImgUsage == VmaBufferImageUsage::UNKNOWN)
         {
-            VMA_ASSERT(0 && "VMA_MEMORY_USAGE_AUTO* values can only be used with functions like vmaCreateBuffer, vmaCreateImage so that the details of the created resource are known.");
+            VMA_ASSERT(0 && "VMA_MEMORY_USAGE_AUTO* values can only be used with functions like vmaCreateBuffer, vmaCreateImage so that the details of the created resource are known."
+                " Maybe you use VkBufferUsageFlags2CreateInfoKHR but forgot to use VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT?" );
             return false;
         }
-        // This relies on values of VK_IMAGE_USAGE_TRANSFER* being the same VK_BUFFER_IMAGE_TRANSFER*.
-        const bool deviceAccess = (bufImgUsage & ~static_cast<VkFlags>(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) != 0;
+
+        const bool deviceAccess = bufImgUsage.ContainsDeviceAccess();
         const bool hostAccessSequentialWrite = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT) != 0;
         const bool hostAccessRandom = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT) != 0;
         const bool hostAccessAllowTransferInstead = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT) != 0;
@@ -4109,7 +4291,7 @@ public:
             --(*m_Atomic);
     }
 
-    void Commit() { m_Atomic = nullptr; }
+    void Commit() { m_Atomic = VMA_NULL; }
     T Increment(AtomicT* atomic)
     {
         m_Atomic = atomic;
@@ -4117,7 +4299,7 @@ public:
     }
 
 private:
-    AtomicT* m_Atomic = nullptr;
+    AtomicT* m_Atomic = VMA_NULL;
 };
 #endif // _VMA_ATOMIC_TRANSACTIONAL_INCREMENT
 
@@ -5384,99 +5566,6 @@ void VmaIntrusiveLinkedList<ItemTypeTraits>::RemoveAll()
 #endif // _VMA_INTRUSIVE_LINKED_LIST_FUNCTIONS
 #endif // _VMA_INTRUSIVE_LINKED_LIST
 
-// Unused in this version.
-#if 0
-
-#ifndef _VMA_PAIR
-template<typename T1, typename T2>
-struct VmaPair
-{
-    T1 first;
-    T2 second;
-
-    VmaPair() : first(), second() {}
-    VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) {}
-};
-
-template<typename FirstT, typename SecondT>
-struct VmaPairFirstLess
-{
-    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
-    {
-        return lhs.first < rhs.first;
-    }
-    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
-    {
-        return lhs.first < rhsFirst;
-    }
-};
-#endif // _VMA_PAIR
-
-#ifndef _VMA_MAP
-/* Class compatible with subset of interface of std::unordered_map.
-KeyT, ValueT must be POD because they will be stored in VmaVector.
-*/
-template<typename KeyT, typename ValueT>
-class VmaMap
-{
-public:
-    typedef VmaPair<KeyT, ValueT> PairType;
-    typedef PairType* iterator;
-
-    VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) {}
-
-    iterator begin() { return m_Vector.begin(); }
-    iterator end() { return m_Vector.end(); }
-    size_t size() { return m_Vector.size(); }
-
-    void insert(const PairType& pair);
-    iterator find(const KeyT& key);
-    void erase(iterator it);
-
-private:
-    VmaVector< PairType, VmaStlAllocator<PairType>> m_Vector;
-};
-
-#ifndef _VMA_MAP_FUNCTIONS
-template<typename KeyT, typename ValueT>
-void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
-{
-    const size_t indexToInsert = VmaBinaryFindFirstNotLess(
-        m_Vector.data(),
-        m_Vector.data() + m_Vector.size(),
-        pair,
-        VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
-    VmaVectorInsert(m_Vector, indexToInsert, pair);
-}
-
-template<typename KeyT, typename ValueT>
-VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
-{
-    PairType* it = VmaBinaryFindFirstNotLess(
-        m_Vector.data(),
-        m_Vector.data() + m_Vector.size(),
-        key,
-        VmaPairFirstLess<KeyT, ValueT>());
-    if ((it != m_Vector.end()) && (it->first == key))
-    {
-        return it;
-    }
-    else
-    {
-        return m_Vector.end();
-    }
-}
-
-template<typename KeyT, typename ValueT>
-void VmaMap<KeyT, ValueT>::erase(iterator it)
-{
-    VmaVectorRemove(m_Vector, it - m_Vector.begin());
-}
-#endif // _VMA_MAP_FUNCTIONS
-#endif // _VMA_MAP
-
-#endif // #if 0
-
 #if !defined(_VMA_STRING_BUILDER) && VMA_STATS_STRING_ENABLED
 class VmaStringBuilder
 {
@@ -6139,9 +6228,17 @@ public:
     void DedicatedAllocUnmap(VmaAllocator hAllocator);
 
 #if VMA_STATS_STRING_ENABLED
-    uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
-
-    void InitBufferImageUsage(uint32_t bufferImageUsage);
+    VmaBufferImageUsage GetBufferImageUsage() const { return m_BufferImageUsage; }
+    void InitBufferUsage(const VkBufferCreateInfo &createInfo, bool useKhrMaintenance5)
+    {
+        VMA_ASSERT(m_BufferImageUsage == VmaBufferImageUsage::UNKNOWN);
+        m_BufferImageUsage = VmaBufferImageUsage(createInfo, useKhrMaintenance5);
+    }
+    void InitImageUsage(const VkImageCreateInfo &createInfo)
+    {
+        VMA_ASSERT(m_BufferImageUsage == VmaBufferImageUsage::UNKNOWN);
+        m_BufferImageUsage = VmaBufferImageUsage(createInfo);
+    }
     void PrintParameters(class VmaJsonWriter& json) const;
 #endif
 
@@ -6180,7 +6277,7 @@ private:
     uint8_t m_MapCount;
     uint8_t m_Flags; // enum FLAGS
 #if VMA_STATS_STRING_ENABLED
-    uint32_t m_BufferImageUsage; // 0 if unknown.
+    VmaBufferImageUsage m_BufferImageUsage; // 0 if unknown.
 #endif
 };
 #endif // _VMA_ALLOCATION_T
@@ -6276,7 +6373,7 @@ bool VmaDedicatedAllocationList::Validate()
 
 void VmaDedicatedAllocationList::AddDetailedStatistics(VmaDetailedStatistics& inoutStats)
 {
-    for(auto* item = m_AllocationList.Front(); item != nullptr; item = DedicatedAllocationLinkedList::GetNext(item))
+    for(auto* item = m_AllocationList.Front(); item != VMA_NULL; item = DedicatedAllocationLinkedList::GetNext(item))
     {
         const VkDeviceSize size = item->GetSize();
         inoutStats.statistics.blockCount++;
@@ -6293,7 +6390,7 @@ void VmaDedicatedAllocationList::AddStatistics(VmaStatistics& inoutStats)
     inoutStats.blockCount += allocCount;
     inoutStats.allocationCount += allocCount;
 
-    for(auto* item = m_AllocationList.Front(); item != nullptr; item = DedicatedAllocationLinkedList::GetNext(item))
+    for(auto* item = m_AllocationList.Front(); item != VMA_NULL; item = DedicatedAllocationLinkedList::GetNext(item))
     {
         const VkDeviceSize size = item->GetSize();
         inoutStats.blockBytes += size;
@@ -6509,7 +6606,7 @@ void VmaBlockMetadata::DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size
 {
     if (IsVirtual())
     {
-        VMA_DEBUG_LOG_FORMAT("UNFREED VIRTUAL ALLOCATION; Offset: %llu; Size: %llu; UserData: %p", offset, size, userData);
+        VMA_LEAK_LOG_FORMAT("UNFREED VIRTUAL ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p", offset, size, userData);
     }
     else
     {
@@ -6520,14 +6617,14 @@ void VmaBlockMetadata::DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size
         const char* name = allocation->GetName();
 
 #if VMA_STATS_STRING_ENABLED
-        VMA_DEBUG_LOG_FORMAT("UNFREED ALLOCATION; Offset: %llu; Size: %llu; UserData: %p; Name: %s; Type: %s; Usage: %u",
+        VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %s; Usage: %" PRIu64,
             offset, size, userData, name ? name : "vma_empty",
             VMA_SUBALLOCATION_TYPE_NAMES[allocation->GetSuballocationType()],
-            allocation->GetBufferImageUsage());
+            (uint64_t)allocation->GetBufferImageUsage().Value);
 #else
-        VMA_DEBUG_LOG_FORMAT("UNFREED ALLOCATION; Offset: %llu; Size: %llu; UserData: %p; Name: %s; Type: %u",
+        VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %u",
             offset, size, userData, name ? name : "vma_empty",
-            (uint32_t)allocation->GetSuballocationType());
+            (unsigned)allocation->GetSuballocationType());
 #endif // VMA_STATS_STRING_ENABLED
     }
 
@@ -6841,770 +6938,6 @@ void VmaBlockBufferImageGranularity::AllocPage(RegionInfo& page, uint8_t allocTy
 #endif // _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY_FUNCTIONS
 #endif // _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY
 
-#if 0
-#ifndef _VMA_BLOCK_METADATA_GENERIC
-class VmaBlockMetadata_Generic : public VmaBlockMetadata
-{
-    friend class VmaDefragmentationAlgorithm_Generic;
-    friend class VmaDefragmentationAlgorithm_Fast;
-    VMA_CLASS_NO_COPY_NO_MOVE(VmaBlockMetadata_Generic)
-public:
-    VmaBlockMetadata_Generic(const VkAllocationCallbacks* pAllocationCallbacks,
-        VkDeviceSize bufferImageGranularity, bool isVirtual);
-    virtual ~VmaBlockMetadata_Generic() = default;
-
-    size_t GetAllocationCount() const override { return m_Suballocations.size() - m_FreeCount; }
-    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize; }
-    bool IsEmpty() const override { return (m_Suballocations.size() == 1) && (m_FreeCount == 1); }
-    void Free(VmaAllocHandle allocHandle) override { FreeSuballocation(FindAtOffset((VkDeviceSize)allocHandle - 1)); }
-    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; }
-
-    void Init(VkDeviceSize size) override;
-    bool Validate() const override;
-
-    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
-    void AddStatistics(VmaStatistics& inoutStats) const override;
-
-#if VMA_STATS_STRING_ENABLED
-    void PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const override;
-#endif
-
-    bool CreateAllocationRequest(
-        VkDeviceSize allocSize,
-        VkDeviceSize allocAlignment,
-        bool upperAddress,
-        VmaSuballocationType allocType,
-        uint32_t strategy,
-        VmaAllocationRequest* pAllocationRequest) override;
-
-    VkResult CheckCorruption(const void* pBlockData) override;
-
-    void Alloc(
-        const VmaAllocationRequest& request,
-        VmaSuballocationType type,
-        void* userData) override;
-
-    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
-    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
-    VmaAllocHandle GetAllocationListBegin() const override;
-    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
-    void Clear() override;
-    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
-    void DebugLogAllAllocations() const override;
-
-private:
-    uint32_t m_FreeCount;
-    VkDeviceSize m_SumFreeSize;
-    VmaSuballocationList m_Suballocations;
-    // Suballocations that are free. Sorted by size, ascending.
-    VmaVector<VmaSuballocationList::iterator, VmaStlAllocator<VmaSuballocationList::iterator>> m_FreeSuballocationsBySize;
-
-    VkDeviceSize AlignAllocationSize(VkDeviceSize size) const { return IsVirtual() ? size : VmaAlignUp(size, (VkDeviceSize)16); }
-
-    VmaSuballocationList::iterator FindAtOffset(VkDeviceSize offset) const;
-    bool ValidateFreeSuballocationList() const;
-
-    // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
-    // If yes, fills pOffset and returns true. If no, returns false.
-    bool CheckAllocation(
-        VkDeviceSize allocSize,
-        VkDeviceSize allocAlignment,
-        VmaSuballocationType allocType,
-        VmaSuballocationList::const_iterator suballocItem,
-        VmaAllocHandle* pAllocHandle) const;
-
-    // Given free suballocation, it merges it with following one, which must also be free.
-    void MergeFreeWithNext(VmaSuballocationList::iterator item);
-    // Releases given suballocation, making it free.
-    // Merges it with adjacent free suballocations if applicable.
-    // Returns iterator to new free suballocation at this place.
-    VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
-    // Given free suballocation, it inserts it into sorted list of
-    // m_FreeSuballocationsBySize if it is suitable.
-    void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
-    // Given free suballocation, it removes it from sorted list of
-    // m_FreeSuballocationsBySize if it is suitable.
-    void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
-};
-
-#ifndef _VMA_BLOCK_METADATA_GENERIC_FUNCTIONS
-VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(const VkAllocationCallbacks* pAllocationCallbacks,
-    VkDeviceSize bufferImageGranularity, bool isVirtual)
-    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
-    m_FreeCount(0),
-    m_SumFreeSize(0),
-    m_Suballocations(VmaStlAllocator<VmaSuballocation>(pAllocationCallbacks)),
-    m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(pAllocationCallbacks)) {}
-
-void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
-{
-    VmaBlockMetadata::Init(size);
-
-    m_FreeCount = 1;
-    m_SumFreeSize = size;
-
-    VmaSuballocation suballoc = {};
-    suballoc.offset = 0;
-    suballoc.size = size;
-    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
-
-    m_Suballocations.push_back(suballoc);
-    m_FreeSuballocationsBySize.push_back(m_Suballocations.begin());
-}
-
-bool VmaBlockMetadata_Generic::Validate() const
-{
-    VMA_VALIDATE(!m_Suballocations.empty());
-
-    // Expected offset of new suballocation as calculated from previous ones.
-    VkDeviceSize calculatedOffset = 0;
-    // Expected number of free suballocations as calculated from traversing their list.
-    uint32_t calculatedFreeCount = 0;
-    // Expected sum size of free suballocations as calculated from traversing their list.
-    VkDeviceSize calculatedSumFreeSize = 0;
-    // Expected number of free suballocations that should be registered in
-    // m_FreeSuballocationsBySize calculated from traversing their list.
-    size_t freeSuballocationsToRegister = 0;
-    // True if previous visited suballocation was free.
-    bool prevFree = false;
-
-    const VkDeviceSize debugMargin = GetDebugMargin();
-
-    for (const auto& subAlloc : m_Suballocations)
-    {
-        // Actual offset of this suballocation doesn't match expected one.
-        VMA_VALIDATE(subAlloc.offset == calculatedOffset);
-
-        const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
-        // Two adjacent free suballocations are invalid. They should be merged.
-        VMA_VALIDATE(!prevFree || !currFree);
-
-        VmaAllocation alloc = (VmaAllocation)subAlloc.userData;
-        if (!IsVirtual())
-        {
-            VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
-        }
-
-        if (currFree)
-        {
-            calculatedSumFreeSize += subAlloc.size;
-            ++calculatedFreeCount;
-            ++freeSuballocationsToRegister;
-
-            // Margin required between allocations - every free space must be at least that large.
-            VMA_VALIDATE(subAlloc.size >= debugMargin);
-        }
-        else
-        {
-            if (!IsVirtual())
-            {
-                VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == subAlloc.offset + 1);
-                VMA_VALIDATE(alloc->GetSize() == subAlloc.size);
-            }
-
-            // Margin required between allocations - previous allocation must be free.
-            VMA_VALIDATE(debugMargin == 0 || prevFree);
-        }
-
-        calculatedOffset += subAlloc.size;
-        prevFree = currFree;
-    }
-
-    // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
-    // match expected one.
-    VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
-
-    VkDeviceSize lastSize = 0;
-    for (size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
-    {
-        VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
-
-        // Only free suballocations can be registered in m_FreeSuballocationsBySize.
-        VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
-        // They must be sorted by size ascending.
-        VMA_VALIDATE(suballocItem->size >= lastSize);
-
-        lastSize = suballocItem->size;
-    }
-
-    // Check if totals match calculated values.
-    VMA_VALIDATE(ValidateFreeSuballocationList());
-    VMA_VALIDATE(calculatedOffset == GetSize());
-    VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
-    VMA_VALIDATE(calculatedFreeCount == m_FreeCount);
-
-    return true;
-}
-
-void VmaBlockMetadata_Generic::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
-{
-    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
-    inoutStats.statistics.blockCount++;
-    inoutStats.statistics.blockBytes += GetSize();
-
-    for (const auto& suballoc : m_Suballocations)
-    {
-        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
-            VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);
-        else
-            VmaAddDetailedStatisticsUnusedRange(inoutStats, suballoc.size);
-    }
-}
-
-void VmaBlockMetadata_Generic::AddStatistics(VmaStatistics& inoutStats) const
-{
-    inoutStats.blockCount++;
-    inoutStats.allocationCount += (uint32_t)m_Suballocations.size() - m_FreeCount;
-    inoutStats.blockBytes += GetSize();
-    inoutStats.allocationBytes += GetSize() - m_SumFreeSize;
-}
-
-#if VMA_STATS_STRING_ENABLED
-void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const
-{
-    PrintDetailedMap_Begin(json,
-        m_SumFreeSize, // unusedBytes
-        m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
-        m_FreeCount, // unusedRangeCount
-        mapRefCount);
-
-    for (const auto& suballoc : m_Suballocations)
-    {
-        if (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
-        {
-            PrintDetailedMap_UnusedRange(json, suballoc.offset, suballoc.size);
-        }
-        else
-        {
-            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);
-        }
-    }
-
-    PrintDetailedMap_End(json);
-}
-#endif // VMA_STATS_STRING_ENABLED
-
-bool VmaBlockMetadata_Generic::CreateAllocationRequest(
-    VkDeviceSize allocSize,
-    VkDeviceSize allocAlignment,
-    bool upperAddress,
-    VmaSuballocationType allocType,
-    uint32_t strategy,
-    VmaAllocationRequest* pAllocationRequest)
-{
-    VMA_ASSERT(allocSize > 0);
-    VMA_ASSERT(!upperAddress);
-    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
-    VMA_ASSERT(pAllocationRequest != VMA_NULL);
-    VMA_HEAVY_ASSERT(Validate());
-
-    allocSize = AlignAllocationSize(allocSize);
-
-    pAllocationRequest->type = VmaAllocationRequestType::Normal;
-    pAllocationRequest->size = allocSize;
-
-    const VkDeviceSize debugMargin = GetDebugMargin();
-
-    // There is not enough total free space in this block to fulfill the request: Early return.
-    if (m_SumFreeSize < allocSize + debugMargin)
-    {
-        return false;
-    }
-
-    // New algorithm, efficiently searching freeSuballocationsBySize.
-    const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
-    if (freeSuballocCount > 0)
-    {
-        if (strategy == 0 ||
-            strategy == VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT)
-        {
-            // Find first free suballocation with size not less than allocSize + debugMargin.
-            VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
-                m_FreeSuballocationsBySize.data(),
-                m_FreeSuballocationsBySize.data() + freeSuballocCount,
-                allocSize + debugMargin,
-                VmaSuballocationItemSizeLess());
-            size_t index = it - m_FreeSuballocationsBySize.data();
-            for (; index < freeSuballocCount; ++index)
-            {
-                if (CheckAllocation(
-                    allocSize,
-                    allocAlignment,
-                    allocType,
-                    m_FreeSuballocationsBySize[index],
-                    &pAllocationRequest->allocHandle))
-                {
-                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
-                    return true;
-                }
-            }
-        }
-        else if (strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
-        {
-            for (VmaSuballocationList::iterator it = m_Suballocations.begin();
-                it != m_Suballocations.end();
-                ++it)
-            {
-                if (it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
-                    allocSize,
-                    allocAlignment,
-                    allocType,
-                    it,
-                    &pAllocationRequest->allocHandle))
-                {
-                    pAllocationRequest->item = it;
-                    return true;
-                }
-            }
-        }
-        else
-        {
-            VMA_ASSERT(strategy & (VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT | VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT ));
-            // Search staring from biggest suballocations.
-            for (size_t index = freeSuballocCount; index--; )
-            {
-                if (CheckAllocation(
-                    allocSize,
-                    allocAlignment,
-                    allocType,
-                    m_FreeSuballocationsBySize[index],
-                    &pAllocationRequest->allocHandle))
-                {
-                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
-                    return true;
-                }
-            }
-        }
-    }
-
-    return false;
-}
-
-VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
-{
-    for (auto& suballoc : m_Suballocations)
-    {
-        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
-        {
-            if (!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
-            {
-                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
-                return VK_ERROR_UNKNOWN_COPY;
-            }
-        }
-    }
-
-    return VK_SUCCESS;
-}
-
-void VmaBlockMetadata_Generic::Alloc(
-    const VmaAllocationRequest& request,
-    VmaSuballocationType type,
-    void* userData)
-{
-    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
-    VMA_ASSERT(request.item != m_Suballocations.end());
-    VmaSuballocation& suballoc = *request.item;
-    // Given suballocation is a free block.
-    VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
-
-    // Given offset is inside this suballocation.
-    VMA_ASSERT((VkDeviceSize)request.allocHandle - 1 >= suballoc.offset);
-    const VkDeviceSize paddingBegin = (VkDeviceSize)request.allocHandle - suballoc.offset - 1;
-    VMA_ASSERT(suballoc.size >= paddingBegin + request.size);
-    const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - request.size;
-
-    // Unregister this free suballocation from m_FreeSuballocationsBySize and update
-    // it to become used.
-    UnregisterFreeSuballocation(request.item);
-
-    suballoc.offset = (VkDeviceSize)request.allocHandle - 1;
-    suballoc.size = request.size;
-    suballoc.type = type;
-    suballoc.userData = userData;
-
-    // If there are any free bytes remaining at the end, insert new free suballocation after current one.
-    if (paddingEnd)
-    {
-        VmaSuballocation paddingSuballoc = {};
-        paddingSuballoc.offset = suballoc.offset + suballoc.size;
-        paddingSuballoc.size = paddingEnd;
-        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
-        VmaSuballocationList::iterator next = request.item;
-        ++next;
-        const VmaSuballocationList::iterator paddingEndItem =
-            m_Suballocations.insert(next, paddingSuballoc);
-        RegisterFreeSuballocation(paddingEndItem);
-    }
-
-    // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
-    if (paddingBegin)
-    {
-        VmaSuballocation paddingSuballoc = {};
-        paddingSuballoc.offset = suballoc.offset - paddingBegin;
-        paddingSuballoc.size = paddingBegin;
-        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
-        const VmaSuballocationList::iterator paddingBeginItem =
-            m_Suballocations.insert(request.item, paddingSuballoc);
-        RegisterFreeSuballocation(paddingBeginItem);
-    }
-
-    // Update totals.
-    m_FreeCount = m_FreeCount - 1;
-    if (paddingBegin > 0)
-    {
-        ++m_FreeCount;
-    }
-    if (paddingEnd > 0)
-    {
-        ++m_FreeCount;
-    }
-    m_SumFreeSize -= request.size;
-}
-
-void VmaBlockMetadata_Generic::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
-{
-    outInfo.offset = (VkDeviceSize)allocHandle - 1;
-    const VmaSuballocation& suballoc = *FindAtOffset(outInfo.offset);
-    outInfo.size = suballoc.size;
-    outInfo.pUserData = suballoc.userData;
-}
-
-void* VmaBlockMetadata_Generic::GetAllocationUserData(VmaAllocHandle allocHandle) const
-{
-    return FindAtOffset((VkDeviceSize)allocHandle - 1)->userData;
-}
-
-VmaAllocHandle VmaBlockMetadata_Generic::GetAllocationListBegin() const
-{
-    if (IsEmpty())
-        return VK_NULL_HANDLE;
-
-    for (const auto& suballoc : m_Suballocations)
-    {
-        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
-            return (VmaAllocHandle)(suballoc.offset + 1);
-    }
-    VMA_ASSERT(false && "Should contain at least 1 allocation!");
-    return VK_NULL_HANDLE;
-}
-
-VmaAllocHandle VmaBlockMetadata_Generic::GetNextAllocation(VmaAllocHandle prevAlloc) const
-{
-    VmaSuballocationList::const_iterator prev = FindAtOffset((VkDeviceSize)prevAlloc - 1);
-
-    for (VmaSuballocationList::const_iterator it = ++prev; it != m_Suballocations.end(); ++it)
-    {
-        if (it->type != VMA_SUBALLOCATION_TYPE_FREE)
-            return (VmaAllocHandle)(it->offset + 1);
-    }
-    return VK_NULL_HANDLE;
-}
-
-void VmaBlockMetadata_Generic::Clear()
-{
-    const VkDeviceSize size = GetSize();
-
-    VMA_ASSERT(IsVirtual());
-    m_FreeCount = 1;
-    m_SumFreeSize = size;
-    m_Suballocations.clear();
-    m_FreeSuballocationsBySize.clear();
-
-    VmaSuballocation suballoc = {};
-    suballoc.offset = 0;
-    suballoc.size = size;
-    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
-    m_Suballocations.push_back(suballoc);
-
-    m_FreeSuballocationsBySize.push_back(m_Suballocations.begin());
-}
-
-void VmaBlockMetadata_Generic::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
-{
-    VmaSuballocation& suballoc = *FindAtOffset((VkDeviceSize)allocHandle - 1);
-    suballoc.userData = userData;
-}
-
-void VmaBlockMetadata_Generic::DebugLogAllAllocations() const
-{
-    for (const auto& suballoc : m_Suballocations)
-    {
-        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
-            DebugLogAllocation(suballoc.offset, suballoc.size, suballoc.userData);
-    }
-}
-
-VmaSuballocationList::iterator VmaBlockMetadata_Generic::FindAtOffset(VkDeviceSize offset) const
-{
-    VMA_HEAVY_ASSERT(!m_Suballocations.empty());
-    const VkDeviceSize last = m_Suballocations.rbegin()->offset;
-    if (last == offset)
-        return m_Suballocations.rbegin().drop_const();
-    const VkDeviceSize first = m_Suballocations.begin()->offset;
-    if (first == offset)
-        return m_Suballocations.begin().drop_const();
-
-    const size_t suballocCount = m_Suballocations.size();
-    const VkDeviceSize step = (last - first + m_Suballocations.begin()->size) / suballocCount;
-    auto findSuballocation = [&](auto begin, auto end) -> VmaSuballocationList::iterator
-    {
-        for (auto suballocItem = begin;
-            suballocItem != end;
-            ++suballocItem)
-        {
-            if (suballocItem->offset == offset)
-                return suballocItem.drop_const();
-        }
-        VMA_ASSERT(false && "Not found!");
-        return m_Suballocations.end().drop_const();
-    };
-    // If requested offset is closer to the end of range, search from the end
-    if (offset - first > suballocCount * step / 2)
-    {
-        return findSuballocation(m_Suballocations.rbegin(), m_Suballocations.rend());
-    }
-    return findSuballocation(m_Suballocations.begin(), m_Suballocations.end());
-}
-
-bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
-{
-    VkDeviceSize lastSize = 0;
-    for (size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
-    {
-        const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
-
-        VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
-        VMA_VALIDATE(it->size >= lastSize);
-        lastSize = it->size;
-    }
-    return true;
-}
-
-bool VmaBlockMetadata_Generic::CheckAllocation(
-    VkDeviceSize allocSize,
-    VkDeviceSize allocAlignment,
-    VmaSuballocationType allocType,
-    VmaSuballocationList::const_iterator suballocItem,
-    VmaAllocHandle* pAllocHandle) const
-{
-    VMA_ASSERT(allocSize > 0);
-    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
-    VMA_ASSERT(suballocItem != m_Suballocations.cend());
-    VMA_ASSERT(pAllocHandle != VMA_NULL);
-
-    const VkDeviceSize debugMargin = GetDebugMargin();
-    const VkDeviceSize bufferImageGranularity = GetBufferImageGranularity();
-
-    const VmaSuballocation& suballoc = *suballocItem;
-    VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
-
-    // Size of this suballocation is too small for this request: Early return.
-    if (suballoc.size < allocSize)
-    {
-        return false;
-    }
-
-    // Start from offset equal to beginning of this suballocation.
-    VkDeviceSize offset = suballoc.offset + (suballocItem == m_Suballocations.cbegin() ? 0 : GetDebugMargin());
-
-    // Apply debugMargin from the end of previous alloc.
-    if (debugMargin > 0)
-    {
-        offset += debugMargin;
-    }
-
-    // Apply alignment.
-    offset = VmaAlignUp(offset, allocAlignment);
-
-    // Check previous suballocations for BufferImageGranularity conflicts.
-    // Make bigger alignment if necessary.
-    if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment)
-    {
-        bool bufferImageGranularityConflict = false;
-        VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
-        while (prevSuballocItem != m_Suballocations.cbegin())
-        {
-            --prevSuballocItem;
-            const VmaSuballocation& prevSuballoc = *prevSuballocItem;
-            if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, offset, bufferImageGranularity))
-            {
-                if (VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
-                {
-                    bufferImageGranularityConflict = true;
-                    break;
-                }
-            }
-            else
-                // Already on previous page.
-                break;
-        }
-        if (bufferImageGranularityConflict)
-        {
-            offset = VmaAlignUp(offset, bufferImageGranularity);
-        }
-    }
-
-    // Calculate padding at the beginning based on current offset.
-    const VkDeviceSize paddingBegin = offset - suballoc.offset;
-
-    // Fail if requested size plus margin after is bigger than size of this suballocation.
-    if (paddingBegin + allocSize + debugMargin > suballoc.size)
-    {
-        return false;
-    }
-
-    // Check next suballocations for BufferImageGranularity conflicts.
-    // If conflict exists, allocation cannot be made here.
-    if (allocSize % bufferImageGranularity || offset % bufferImageGranularity)
-    {
-        VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
-        ++nextSuballocItem;
-        while (nextSuballocItem != m_Suballocations.cend())
-        {
-            const VmaSuballocation& nextSuballoc = *nextSuballocItem;
-            if (VmaBlocksOnSamePage(offset, allocSize, nextSuballoc.offset, bufferImageGranularity))
-            {
-                if (VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
-                {
-                    return false;
-                }
-            }
-            else
-            {
-                // Already on next page.
-                break;
-            }
-            ++nextSuballocItem;
-        }
-    }
-
-    *pAllocHandle = (VmaAllocHandle)(offset + 1);
-    // All tests passed: Success. pAllocHandle is already filled.
-    return true;
-}
-
-void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
-{
-    VMA_ASSERT(item != m_Suballocations.end());
-    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
-
-    VmaSuballocationList::iterator nextItem = item;
-    ++nextItem;
-    VMA_ASSERT(nextItem != m_Suballocations.end());
-    VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
-
-    item->size += nextItem->size;
-    --m_FreeCount;
-    m_Suballocations.erase(nextItem);
-}
-
-VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
-{
-    // Change this suballocation to be marked as free.
-    VmaSuballocation& suballoc = *suballocItem;
-    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
-    suballoc.userData = VMA_NULL;
-
-    // Update totals.
-    ++m_FreeCount;
-    m_SumFreeSize += suballoc.size;
-
-    // Merge with previous and/or next suballocation if it's also free.
-    bool mergeWithNext = false;
-    bool mergeWithPrev = false;
-
-    VmaSuballocationList::iterator nextItem = suballocItem;
-    ++nextItem;
-    if ((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
-    {
-        mergeWithNext = true;
-    }
-
-    VmaSuballocationList::iterator prevItem = suballocItem;
-    if (suballocItem != m_Suballocations.begin())
-    {
-        --prevItem;
-        if (prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
-        {
-            mergeWithPrev = true;
-        }
-    }
-
-    if (mergeWithNext)
-    {
-        UnregisterFreeSuballocation(nextItem);
-        MergeFreeWithNext(suballocItem);
-    }
-
-    if (mergeWithPrev)
-    {
-        UnregisterFreeSuballocation(prevItem);
-        MergeFreeWithNext(prevItem);
-        RegisterFreeSuballocation(prevItem);
-        return prevItem;
-    }
-    else
-    {
-        RegisterFreeSuballocation(suballocItem);
-        return suballocItem;
-    }
-}
-
-void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
-{
-    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
-    VMA_ASSERT(item->size > 0);
-
-    // You may want to enable this validation at the beginning or at the end of
-    // this function, depending on what do you want to check.
-    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
-
-    if (m_FreeSuballocationsBySize.empty())
-    {
-        m_FreeSuballocationsBySize.push_back(item);
-    }
-    else
-    {
-        VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
-    }
-
-    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
-}
-
-void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
-{
-    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
-    VMA_ASSERT(item->size > 0);
-
-    // You may want to enable this validation at the beginning or at the end of
-    // this function, depending on what do you want to check.
-    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
-
-    VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
-        m_FreeSuballocationsBySize.data(),
-        m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
-        item,
-        VmaSuballocationItemSizeLess());
-    for (size_t index = it - m_FreeSuballocationsBySize.data();
-        index < m_FreeSuballocationsBySize.size();
-        ++index)
-    {
-        if (m_FreeSuballocationsBySize[index] == item)
-        {
-            VmaVectorRemove(m_FreeSuballocationsBySize, index);
-            return;
-        }
-        VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
-    }
-    VMA_ASSERT(0 && "Not found.");
-
-    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
-}
-#endif // _VMA_BLOCK_METADATA_GENERIC_FUNCTIONS
-#endif // _VMA_BLOCK_METADATA_GENERIC
-#endif // #if 0
-
 #ifndef _VMA_BLOCK_METADATA_LINEAR
 /*
 Allocations and their references in internal data structure look like this:
@@ -8355,7 +7688,7 @@ void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
         // We are at the end.
         else
         {
-            if (lastOffset < size)
+            if (lastOffset < freeSpace1stTo2ndEnd)
             {
                 // There is free space from lastOffset to freeSpace1stTo2ndEnd.
                 ++unusedRangeCount;
@@ -8581,6 +7914,10 @@ bool VmaBlockMetadata_Linear::CreateAllocationRequest(
     VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
     VMA_ASSERT(pAllocationRequest != VMA_NULL);
     VMA_HEAVY_ASSERT(Validate());
+
+    if(allocSize > GetSize())
+        return false;
+
     pAllocationRequest->size = allocSize;
     return upperAddress ?
         CreateAllocationRequest_UpperAddress(
@@ -9290,713 +8627,6 @@ bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
 #endif // _VMA_BLOCK_METADATA_LINEAR_FUNCTIONS
 #endif // _VMA_BLOCK_METADATA_LINEAR
 
-#if 0
-#ifndef _VMA_BLOCK_METADATA_BUDDY
-/*
-- GetSize() is the original size of allocated memory block.
-- m_UsableSize is this size aligned down to a power of two.
-  All allocations and calculations happen relative to m_UsableSize.
-- GetUnusableSize() is the difference between them.
-  It is reported as separate, unused range, not available for allocations.
-
-Node at level 0 has size = m_UsableSize.
-Each next level contains nodes with size 2 times smaller than current level.
-m_LevelCount is the maximum number of levels to use in the current object.
-*/
-class VmaBlockMetadata_Buddy : public VmaBlockMetadata
-{
-    VMA_CLASS_NO_COPY_NO_MOVE(VmaBlockMetadata_Buddy)
-public:
-    VmaBlockMetadata_Buddy(const VkAllocationCallbacks* pAllocationCallbacks,
-        VkDeviceSize bufferImageGranularity, bool isVirtual);
-    virtual ~VmaBlockMetadata_Buddy();
-
-    size_t GetAllocationCount() const override { return m_AllocationCount; }
-    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize + GetUnusableSize(); }
-    bool IsEmpty() const override { return m_Root->type == Node::TYPE_FREE; }
-    VkResult CheckCorruption(const void* pBlockData) override { return VK_ERROR_FEATURE_NOT_PRESENT; }
-    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; }
-    void DebugLogAllAllocations() const override { DebugLogAllAllocationNode(m_Root, 0); }
-
-    void Init(VkDeviceSize size) override;
-    bool Validate() const override;
-
-    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
-    void AddStatistics(VmaStatistics& inoutStats) const override;
-
-#if VMA_STATS_STRING_ENABLED
-    void PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const override;
-#endif
-
-    bool CreateAllocationRequest(
-        VkDeviceSize allocSize,
-        VkDeviceSize allocAlignment,
-        bool upperAddress,
-        VmaSuballocationType allocType,
-        uint32_t strategy,
-        VmaAllocationRequest* pAllocationRequest) override;
-
-    void Alloc(
-        const VmaAllocationRequest& request,
-        VmaSuballocationType type,
-        void* userData) override;
-
-    void Free(VmaAllocHandle allocHandle) override;
-    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
-    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
-    VmaAllocHandle GetAllocationListBegin() const override;
-    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
-    void Clear() override;
-    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
-
-private:
-    static const size_t MAX_LEVELS = 48;
-
-    struct ValidationContext
-    {
-        size_t calculatedAllocationCount = 0;
-        size_t calculatedFreeCount = 0;
-        VkDeviceSize calculatedSumFreeSize = 0;
-    };
-    struct Node
-    {
-        VkDeviceSize offset;
-        enum TYPE
-        {
-            TYPE_FREE,
-            TYPE_ALLOCATION,
-            TYPE_SPLIT,
-            TYPE_COUNT
-        } type;
-        Node* parent;
-        Node* buddy;
-
-        union
-        {
-            struct
-            {
-                Node* prev;
-                Node* next;
-            } free;
-            struct
-            {
-                void* userData;
-            } allocation;
-            struct
-            {
-                Node* leftChild;
-            } split;
-        };
-    };
-
-    // Size of the memory block aligned down to a power of two.
-    VkDeviceSize m_UsableSize;
-    uint32_t m_LevelCount;
-    VmaPoolAllocator<Node> m_NodeAllocator;
-    Node* m_Root;
-    struct
-    {
-        Node* front;
-        Node* back;
-    } m_FreeList[MAX_LEVELS];
-
-    // Number of nodes in the tree with type == TYPE_ALLOCATION.
-    size_t m_AllocationCount;
-    // Number of nodes in the tree with type == TYPE_FREE.
-    size_t m_FreeCount;
-    // Doesn't include space wasted due to internal fragmentation - allocation sizes are just aligned up to node sizes.
-    // Doesn't include unusable size.
-    VkDeviceSize m_SumFreeSize;
-
-    VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
-    VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }
-
-    VkDeviceSize AlignAllocationSize(VkDeviceSize size) const
-    {
-        if (!IsVirtual())
-        {
-            size = VmaAlignUp(size, (VkDeviceSize)16);
-        }
-        return VmaNextPow2(size);
-    }
-    Node* FindAllocationNode(VkDeviceSize offset, uint32_t& outLevel) const;
-    void DeleteNodeChildren(Node* node);
-    bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
-    uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
-    void AddNodeToDetailedStatistics(VmaDetailedStatistics& inoutStats, const Node* node, VkDeviceSize levelNodeSize) const;
-    // Adds node to the front of FreeList at given level.
-    // node->type must be FREE.
-    // node->free.prev, next can be undefined.
-    void AddToFreeListFront(uint32_t level, Node* node);
-    // Removes node from FreeList at given level.
-    // node->type must be FREE.
-    // node->free.prev, next stay untouched.
-    void RemoveFromFreeList(uint32_t level, Node* node);
-    void DebugLogAllAllocationNode(Node* node, uint32_t level) const;
-
-#if VMA_STATS_STRING_ENABLED
-    void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
-#endif
-};
-
-#ifndef _VMA_BLOCK_METADATA_BUDDY_FUNCTIONS
-VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(const VkAllocationCallbacks* pAllocationCallbacks,
-    VkDeviceSize bufferImageGranularity, bool isVirtual)
-    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
-    m_NodeAllocator(pAllocationCallbacks, 32), // firstBlockCapacity
-    m_Root(VMA_NULL),
-    m_AllocationCount(0),
-    m_FreeCount(1),
-    m_SumFreeSize(0)
-{
-    memset(m_FreeList, 0, sizeof(m_FreeList));
-}
-
-VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
-{
-    DeleteNodeChildren(m_Root);
-    m_NodeAllocator.Free(m_Root);
-}
-
-void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
-{
-    VmaBlockMetadata::Init(size);
-
-    m_UsableSize = VmaPrevPow2(size);
-    m_SumFreeSize = m_UsableSize;
-
-    // Calculate m_LevelCount.
-    const VkDeviceSize minNodeSize = IsVirtual() ? 1 : 16;
-    m_LevelCount = 1;
-    while (m_LevelCount < MAX_LEVELS &&
-        LevelToNodeSize(m_LevelCount) >= minNodeSize)
-    {
-        ++m_LevelCount;
-    }
-
-    Node* rootNode = m_NodeAllocator.Alloc();
-    rootNode->offset = 0;
-    rootNode->type = Node::TYPE_FREE;
-    rootNode->parent = VMA_NULL;
-    rootNode->buddy = VMA_NULL;
-
-    m_Root = rootNode;
-    AddToFreeListFront(0, rootNode);
-}
-
-bool VmaBlockMetadata_Buddy::Validate() const
-{
-    // Validate tree.
-    ValidationContext ctx;
-    if (!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
-    {
-        VMA_VALIDATE(false && "ValidateNode failed.");
-    }
-    VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
-    VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);
-
-    // Validate free node lists.
-    for (uint32_t level = 0; level < m_LevelCount; ++level)
-    {
-        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
-            m_FreeList[level].front->free.prev == VMA_NULL);
-
-        for (Node* node = m_FreeList[level].front;
-            node != VMA_NULL;
-            node = node->free.next)
-        {
-            VMA_VALIDATE(node->type == Node::TYPE_FREE);
-
-            if (node->free.next == VMA_NULL)
-            {
-                VMA_VALIDATE(m_FreeList[level].back == node);
-            }
-            else
-            {
-                VMA_VALIDATE(node->free.next->free.prev == node);
-            }
-        }
-    }
-
-    // Validate that free lists ar higher levels are empty.
-    for (uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
-    {
-        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
-    }
-
-    return true;
-}
-
-void VmaBlockMetadata_Buddy::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
-{
-    inoutStats.statistics.blockCount++;
-    inoutStats.statistics.blockBytes += GetSize();
-
-    AddNodeToDetailedStatistics(inoutStats, m_Root, LevelToNodeSize(0));
-
-    const VkDeviceSize unusableSize = GetUnusableSize();
-    if (unusableSize > 0)
-        VmaAddDetailedStatisticsUnusedRange(inoutStats, unusableSize);
-}
-
-void VmaBlockMetadata_Buddy::AddStatistics(VmaStatistics& inoutStats) const
-{
-    inoutStats.blockCount++;
-    inoutStats.allocationCount += (uint32_t)m_AllocationCount;
-    inoutStats.blockBytes += GetSize();
-    inoutStats.allocationBytes += GetSize() - m_SumFreeSize;
-}
-
-#if VMA_STATS_STRING_ENABLED
-void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const
-{
-    VmaDetailedStatistics stats;
-    VmaClearDetailedStatistics(stats);
-    AddDetailedStatistics(stats);
-
-    PrintDetailedMap_Begin(
-        json,
-        stats.statistics.blockBytes - stats.statistics.allocationBytes,
-        stats.statistics.allocationCount,
-        stats.unusedRangeCount,
-        mapRefCount);
-
-    PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));
-
-    const VkDeviceSize unusableSize = GetUnusableSize();
-    if (unusableSize > 0)
-    {
-        PrintDetailedMap_UnusedRange(json,
-            m_UsableSize, // offset
-            unusableSize); // size
-    }
-
-    PrintDetailedMap_End(json);
-}
-#endif // VMA_STATS_STRING_ENABLED
-
-bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
-    VkDeviceSize allocSize,
-    VkDeviceSize allocAlignment,
-    bool upperAddress,
-    VmaSuballocationType allocType,
-    uint32_t strategy,
-    VmaAllocationRequest* pAllocationRequest)
-{
-    VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
-
-    allocSize = AlignAllocationSize(allocSize);
-
-    // Simple way to respect bufferImageGranularity. May be optimized some day.
-    // Whenever it might be an OPTIMAL image...
-    if (allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
-        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
-        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
-    {
-        allocAlignment = VMA_MAX(allocAlignment, GetBufferImageGranularity());
-        allocSize = VmaAlignUp(allocSize, GetBufferImageGranularity());
-    }
-
-    if (allocSize > m_UsableSize)
-    {
-        return false;
-    }
-
-    const uint32_t targetLevel = AllocSizeToLevel(allocSize);
-    for (uint32_t level = targetLevel; level--; )
-    {
-        for (Node* freeNode = m_FreeList[level].front;
-            freeNode != VMA_NULL;
-            freeNode = freeNode->free.next)
-        {
-            if (freeNode->offset % allocAlignment == 0)
-            {
-                pAllocationRequest->type = VmaAllocationRequestType::Normal;
-                pAllocationRequest->allocHandle = (VmaAllocHandle)(freeNode->offset + 1);
-                pAllocationRequest->size = allocSize;
-                pAllocationRequest->customData = (void*)(uintptr_t)level;
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-void VmaBlockMetadata_Buddy::Alloc(
-    const VmaAllocationRequest& request,
-    VmaSuballocationType type,
-    void* userData)
-{
-    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
-
-    const uint32_t targetLevel = AllocSizeToLevel(request.size);
-    uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;
-
-    Node* currNode = m_FreeList[currLevel].front;
-    VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
-    const VkDeviceSize offset = (VkDeviceSize)request.allocHandle - 1;
-    while (currNode->offset != offset)
-    {
-        currNode = currNode->free.next;
-        VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
-    }
-
-    // Go down, splitting free nodes.
-    while (currLevel < targetLevel)
-    {
-        // currNode is already first free node at currLevel.
-        // Remove it from list of free nodes at this currLevel.
-        RemoveFromFreeList(currLevel, currNode);
-
-        const uint32_t childrenLevel = currLevel + 1;
-
-        // Create two free sub-nodes.
-        Node* leftChild = m_NodeAllocator.Alloc();
-        Node* rightChild = m_NodeAllocator.Alloc();
-
-        leftChild->offset = currNode->offset;
-        leftChild->type = Node::TYPE_FREE;
-        leftChild->parent = currNode;
-        leftChild->buddy = rightChild;
-
-        rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
-        rightChild->type = Node::TYPE_FREE;
-        rightChild->parent = currNode;
-        rightChild->buddy = leftChild;
-
-        // Convert current currNode to split type.
-        currNode->type = Node::TYPE_SPLIT;
-        currNode->split.leftChild = leftChild;
-
-        // Add child nodes to free list. Order is important!
-        AddToFreeListFront(childrenLevel, rightChild);
-        AddToFreeListFront(childrenLevel, leftChild);
-
-        ++m_FreeCount;
-        ++currLevel;
-        currNode = m_FreeList[currLevel].front;
-
-        /*
-        We can be sure that currNode, as left child of node previously split,
-        also fulfills the alignment requirement.
-        */
-    }
-
-    // Remove from free list.
-    VMA_ASSERT(currLevel == targetLevel &&
-        currNode != VMA_NULL &&
-        currNode->type == Node::TYPE_FREE);
-    RemoveFromFreeList(currLevel, currNode);
-
-    // Convert to allocation node.
-    currNode->type = Node::TYPE_ALLOCATION;
-    currNode->allocation.userData = userData;
-
-    ++m_AllocationCount;
-    --m_FreeCount;
-    m_SumFreeSize -= request.size;
-}
-
-void VmaBlockMetadata_Buddy::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
-{
-    uint32_t level = 0;
-    outInfo.offset = (VkDeviceSize)allocHandle - 1;
-    const Node* const node = FindAllocationNode(outInfo.offset, level);
-    outInfo.size = LevelToNodeSize(level);
-    outInfo.pUserData = node->allocation.userData;
-}
-
-void* VmaBlockMetadata_Buddy::GetAllocationUserData(VmaAllocHandle allocHandle) const
-{
-    uint32_t level = 0;
-    const Node* const node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
-    return node->allocation.userData;
-}
-
-VmaAllocHandle VmaBlockMetadata_Buddy::GetAllocationListBegin() const
-{
-    // Function only used for defragmentation, which is disabled for this algorithm
-    return VK_NULL_HANDLE;
-}
-
-VmaAllocHandle VmaBlockMetadata_Buddy::GetNextAllocation(VmaAllocHandle prevAlloc) const
-{
-    // Function only used for defragmentation, which is disabled for this algorithm
-    return VK_NULL_HANDLE;
-}
-
-void VmaBlockMetadata_Buddy::DeleteNodeChildren(Node* node)
-{
-    if (node->type == Node::TYPE_SPLIT)
-    {
-        DeleteNodeChildren(node->split.leftChild->buddy);
-        DeleteNodeChildren(node->split.leftChild);
-        const VkAllocationCallbacks* allocationCallbacks = GetAllocationCallbacks();
-        m_NodeAllocator.Free(node->split.leftChild->buddy);
-        m_NodeAllocator.Free(node->split.leftChild);
-    }
-}
-
-void VmaBlockMetadata_Buddy::Clear()
-{
-    DeleteNodeChildren(m_Root);
-    m_Root->type = Node::TYPE_FREE;
-    m_AllocationCount = 0;
-    m_FreeCount = 1;
-    m_SumFreeSize = m_UsableSize;
-}
-
-void VmaBlockMetadata_Buddy::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
-{
-    uint32_t level = 0;
-    Node* const node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
-    node->allocation.userData = userData;
-}
-
-VmaBlockMetadata_Buddy::Node* VmaBlockMetadata_Buddy::FindAllocationNode(VkDeviceSize offset, uint32_t& outLevel) const
-{
-    Node* node = m_Root;
-    VkDeviceSize nodeOffset = 0;
-    outLevel = 0;
-    VkDeviceSize levelNodeSize = LevelToNodeSize(0);
-    while (node->type == Node::TYPE_SPLIT)
-    {
-        const VkDeviceSize nextLevelNodeSize = levelNodeSize >> 1;
-        if (offset < nodeOffset + nextLevelNodeSize)
-        {
-            node = node->split.leftChild;
-        }
-        else
-        {
-            node = node->split.leftChild->buddy;
-            nodeOffset += nextLevelNodeSize;
-        }
-        ++outLevel;
-        levelNodeSize = nextLevelNodeSize;
-    }
-
-    VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
-    return node;
-}
-
-bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
-{
-    VMA_VALIDATE(level < m_LevelCount);
-    VMA_VALIDATE(curr->parent == parent);
-    VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
-    VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
-    switch (curr->type)
-    {
-    case Node::TYPE_FREE:
-        // curr->free.prev, next are validated separately.
-        ctx.calculatedSumFreeSize += levelNodeSize;
-        ++ctx.calculatedFreeCount;
-        break;
-    case Node::TYPE_ALLOCATION:
-        ++ctx.calculatedAllocationCount;
-        if (!IsVirtual())
-        {
-            VMA_VALIDATE(curr->allocation.userData != VMA_NULL);
-        }
-        break;
-    case Node::TYPE_SPLIT:
-    {
-        const uint32_t childrenLevel = level + 1;
-        const VkDeviceSize childrenLevelNodeSize = levelNodeSize >> 1;
-        const Node* const leftChild = curr->split.leftChild;
-        VMA_VALIDATE(leftChild != VMA_NULL);
-        VMA_VALIDATE(leftChild->offset == curr->offset);
-        if (!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
-        {
-            VMA_VALIDATE(false && "ValidateNode for left child failed.");
-        }
-        const Node* const rightChild = leftChild->buddy;
-        VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
-        if (!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
-        {
-            VMA_VALIDATE(false && "ValidateNode for right child failed.");
-        }
-    }
-    break;
-    default:
-        return false;
-    }
-
-    return true;
-}
-
-uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
-{
-    // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
-    uint32_t level = 0;
-    VkDeviceSize currLevelNodeSize = m_UsableSize;
-    VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
-    while (allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
-    {
-        ++level;
-        currLevelNodeSize >>= 1;
-        nextLevelNodeSize >>= 1;
-    }
-    return level;
-}
-
-void VmaBlockMetadata_Buddy::Free(VmaAllocHandle allocHandle)
-{
-    uint32_t level = 0;
-    Node* node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
-
-    ++m_FreeCount;
-    --m_AllocationCount;
-    m_SumFreeSize += LevelToNodeSize(level);
-
-    node->type = Node::TYPE_FREE;
-
-    // Join free nodes if possible.
-    while (level > 0 && node->buddy->type == Node::TYPE_FREE)
-    {
-        RemoveFromFreeList(level, node->buddy);
-        Node* const parent = node->parent;
-
-        m_NodeAllocator.Free(node->buddy);
-        m_NodeAllocator.Free(node);
-        parent->type = Node::TYPE_FREE;
-
-        node = parent;
-        --level;
-        --m_FreeCount;
-    }
-
-    AddToFreeListFront(level, node);
-}
-
-void VmaBlockMetadata_Buddy::AddNodeToDetailedStatistics(VmaDetailedStatistics& inoutStats, const Node* node, VkDeviceSize levelNodeSize) const
-{
-    switch (node->type)
-    {
-    case Node::TYPE_FREE:
-        VmaAddDetailedStatisticsUnusedRange(inoutStats, levelNodeSize);
-        break;
-    case Node::TYPE_ALLOCATION:
-        VmaAddDetailedStatisticsAllocation(inoutStats, levelNodeSize);
-        break;
-    case Node::TYPE_SPLIT:
-    {
-        const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
-        const Node* const leftChild = node->split.leftChild;
-        AddNodeToDetailedStatistics(inoutStats, leftChild, childrenNodeSize);
-        const Node* const rightChild = leftChild->buddy;
-        AddNodeToDetailedStatistics(inoutStats, rightChild, childrenNodeSize);
-    }
-    break;
-    default:
-        VMA_ASSERT(0);
-    }
-}
-
-void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
-{
-    VMA_ASSERT(node->type == Node::TYPE_FREE);
-
-    // List is empty.
-    Node* const frontNode = m_FreeList[level].front;
-    if (frontNode == VMA_NULL)
-    {
-        VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
-        node->free.prev = node->free.next = VMA_NULL;
-        m_FreeList[level].front = m_FreeList[level].back = node;
-    }
-    else
-    {
-        VMA_ASSERT(frontNode->free.prev == VMA_NULL);
-        node->free.prev = VMA_NULL;
-        node->free.next = frontNode;
-        frontNode->free.prev = node;
-        m_FreeList[level].front = node;
-    }
-}
-
-void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
-{
-    VMA_ASSERT(m_FreeList[level].front != VMA_NULL);
-
-    // It is at the front.
-    if (node->free.prev == VMA_NULL)
-    {
-        VMA_ASSERT(m_FreeList[level].front == node);
-        m_FreeList[level].front = node->free.next;
-    }
-    else
-    {
-        Node* const prevFreeNode = node->free.prev;
-        VMA_ASSERT(prevFreeNode->free.next == node);
-        prevFreeNode->free.next = node->free.next;
-    }
-
-    // It is at the back.
-    if (node->free.next == VMA_NULL)
-    {
-        VMA_ASSERT(m_FreeList[level].back == node);
-        m_FreeList[level].back = node->free.prev;
-    }
-    else
-    {
-        Node* const nextFreeNode = node->free.next;
-        VMA_ASSERT(nextFreeNode->free.prev == node);
-        nextFreeNode->free.prev = node->free.prev;
-    }
-}
-
-void VmaBlockMetadata_Buddy::DebugLogAllAllocationNode(Node* node, uint32_t level) const
-{
-    switch (node->type)
-    {
-    case Node::TYPE_FREE:
-        break;
-    case Node::TYPE_ALLOCATION:
-        DebugLogAllocation(node->offset, LevelToNodeSize(level), node->allocation.userData);
-        break;
-    case Node::TYPE_SPLIT:
-    {
-        ++level;
-        DebugLogAllAllocationNode(node->split.leftChild, level);
-        DebugLogAllAllocationNode(node->split.leftChild->buddy, level);
-    }
-    break;
-    default:
-        VMA_ASSERT(0);
-    }
-}
-
-#if VMA_STATS_STRING_ENABLED
-void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
-{
-    switch (node->type)
-    {
-    case Node::TYPE_FREE:
-        PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
-        break;
-    case Node::TYPE_ALLOCATION:
-        PrintDetailedMap_Allocation(json, node->offset, levelNodeSize, node->allocation.userData);
-        break;
-    case Node::TYPE_SPLIT:
-    {
-        const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
-        const Node* const leftChild = node->split.leftChild;
-        PrintDetailedMapNode(json, leftChild, childrenNodeSize);
-        const Node* const rightChild = leftChild->buddy;
-        PrintDetailedMapNode(json, rightChild, childrenNodeSize);
-    }
-    break;
-    default:
-        VMA_ASSERT(0);
-    }
-}
-#endif // VMA_STATS_STRING_ENABLED
-#endif // _VMA_BLOCK_METADATA_BUDDY_FUNCTIONS
-#endif // _VMA_BLOCK_METADATA_BUDDY
-#endif // #if 0
-
 #ifndef _VMA_BLOCK_METADATA_TLSF
 // To not search current larger region if first allocation won't succeed and skip to smaller range
 // use with VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT as strategy in CreateAllocationRequest().
@@ -11346,7 +9976,8 @@ VmaVirtualBlock_T::VmaVirtualBlock_T(const VmaVirtualBlockCreateInfo& createInfo
 
 VmaVirtualBlock_T::~VmaVirtualBlock_T()
 {
-    // Define macro VMA_DEBUG_LOG_FORMAT to receive the list of the unfreed allocations
+    // Define macro VMA_DEBUG_LOG_FORMAT or more specialized VMA_LEAK_LOG_FORMAT
+    // to receive the list of the unfreed allocations.
     if (!m_Metadata->IsEmpty())
         m_Metadata->DebugLogAllAllocations();
     // This is the most important assert in the entire library.
@@ -11436,18 +10067,20 @@ struct VmaAllocator_T
 {
     VMA_CLASS_NO_COPY_NO_MOVE(VmaAllocator_T)
 public:
-    bool m_UseMutex;
-    uint32_t m_VulkanApiVersion;
+    const bool m_UseMutex;
+    const uint32_t m_VulkanApiVersion;
     bool m_UseKhrDedicatedAllocation; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
     bool m_UseKhrBindMemory2; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
     bool m_UseExtMemoryBudget;
     bool m_UseAmdDeviceCoherentMemory;
     bool m_UseKhrBufferDeviceAddress;
     bool m_UseExtMemoryPriority;
-    VkDevice m_hDevice;
-    VkInstance m_hInstance;
-    bool m_AllocationCallbacksSpecified;
-    VkAllocationCallbacks m_AllocationCallbacks;
+    bool m_UseKhrMaintenance4;
+    bool m_UseKhrMaintenance5;
+    const VkDevice m_hDevice;
+    const VkInstance m_hInstance;
+    const bool m_AllocationCallbacksSpecified;
+    const VkAllocationCallbacks m_AllocationCallbacks;
     VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
     VmaAllocationObjectAllocator m_AllocationObjectAllocator;
 
@@ -11528,7 +10161,7 @@ public:
     VkResult FindMemoryTypeIndex(
         uint32_t memoryTypeBits,
         const VmaAllocationCreateInfo* pAllocationCreateInfo,
-        VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
+        VmaBufferImageUsage bufImgUsage,
         uint32_t* pMemoryTypeIndex) const;
 
     // Main allocation function.
@@ -11538,7 +10171,7 @@ public:
         bool prefersDedicatedAllocation,
         VkBuffer dedicatedBuffer,
         VkImage dedicatedImage,
-        VkFlags dedicatedBufferImageUsage, // UINT32_MAX if unknown.
+        VmaBufferImageUsage dedicatedBufferImageUsage,
         const VmaAllocationCreateInfo& createInfo,
         VmaSuballocationType suballocType,
         size_t allocationCount,
@@ -11613,6 +10246,17 @@ public:
         const VkDeviceSize* offsets, const VkDeviceSize* sizes,
         VMA_CACHE_OPERATION op);
 
+    VkResult CopyMemoryToAllocation(
+        const void* pSrcHostPointer,
+        VmaAllocation dstAllocation,
+        VkDeviceSize dstAllocationLocalOffset,
+        VkDeviceSize size);
+    VkResult CopyAllocationToMemory(
+        VmaAllocation srcAllocation,
+        VkDeviceSize srcAllocationLocalOffset,
+        void* pDstHostPointer,
+        VkDeviceSize size);
+
     void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
 
     /*
@@ -11672,7 +10316,7 @@ private:
         bool dedicatedPreferred,
         VkBuffer dedicatedBuffer,
         VkImage dedicatedImage,
-        VkFlags dedicatedBufferImageUsage,
+        VmaBufferImageUsage dedicatedBufferImageUsage,
         const VmaAllocationCreateInfo& createInfo,
         uint32_t memTypeIndex,
         VmaSuballocationType suballocType,
@@ -11709,10 +10353,10 @@ private:
         float priority,
         VkBuffer dedicatedBuffer,
         VkImage dedicatedImage,
-        VkFlags dedicatedBufferImageUsage,
+        VmaBufferImageUsage dedicatedBufferImageUsage,
         size_t allocationCount,
         VmaAllocation* pAllocations,
-        const void* pNextChain = nullptr);
+        const void* pNextChain = VMA_NULL);
 
     void FreeDedicatedMemory(const VmaAllocation allocation);
 
@@ -11841,7 +10485,8 @@ void VmaDeviceMemoryBlock::Init(
 
 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
 {
-    // Define macro VMA_DEBUG_LOG_FORMAT to receive the list of the unfreed allocations
+    // Define macro VMA_DEBUG_LOG_FORMAT or more specialized VMA_LEAK_LOG_FORMAT
+    // to receive the list of the unfreed allocations.
     if (!m_pMetadata->IsEmpty())
         m_pMetadata->DebugLogAllAllocations();
     // This is the most important assert in the entire library.
@@ -11886,7 +10531,7 @@ bool VmaDeviceMemoryBlock::Validate() const
 
 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
 {
-    void* pData = nullptr;
+    void* pData = VMA_NULL;
     VkResult res = Map(hAllocator, 1, &pData);
     if (res != VK_SUCCESS)
     {
@@ -11909,11 +10554,11 @@ VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void
 
     VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
     const uint32_t oldTotalMapCount = m_MapCount + m_MappingHysteresis.GetExtraMapping();
-    m_MappingHysteresis.PostMap();
     if (oldTotalMapCount != 0)
     {
-        m_MapCount += count;
         VMA_ASSERT(m_pMappedData != VMA_NULL);
+        m_MappingHysteresis.PostMap();
+        m_MapCount += count;
         if (ppData != VMA_NULL)
         {
             *ppData = m_pMappedData;
@@ -11931,11 +10576,13 @@ VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void
             &m_pMappedData);
         if (result == VK_SUCCESS)
         {
+            VMA_ASSERT(m_pMappedData != VMA_NULL);
+            m_MappingHysteresis.PostMap();
+            m_MapCount = count;
             if (ppData != VMA_NULL)
             {
                 *ppData = m_pMappedData;
             }
-            m_MapCount = count;
         }
         return result;
     }
@@ -12052,10 +10699,6 @@ VmaAllocation_T::VmaAllocation_T(bool mappingAllowed)
 {
     if(mappingAllowed)
         m_Flags |= (uint8_t)FLAG_MAPPING_ALLOWED;
-
-#if VMA_STATS_STRING_ENABLED
-    m_BufferImageUsage = 0;
-#endif
 }
 
 VmaAllocation_T::~VmaAllocation_T()
@@ -12138,11 +10781,11 @@ uint8_t VmaAllocation_T::SwapBlockAllocation(VmaAllocator hAllocator, VmaAllocat
         m_BlockAllocation.m_Block->Unmap(hAllocator, m_MapCount);
 
     m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, allocation);
-    VMA_SWAP(m_BlockAllocation, allocation->m_BlockAllocation);
+    std::swap(m_BlockAllocation, allocation->m_BlockAllocation);
     m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, this);
 
 #if VMA_STATS_STRING_ENABLED
-    VMA_SWAP(m_BufferImageUsage, allocation->m_BufferImageUsage);
+    std::swap(m_BufferImageUsage, allocation->m_BufferImageUsage);
 #endif
     return m_MapCount;
 }
@@ -12317,12 +10960,6 @@ void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
 }
 
 #if VMA_STATS_STRING_ENABLED
-void VmaAllocation_T::InitBufferImageUsage(uint32_t bufferImageUsage)
-{
-    VMA_ASSERT(m_BufferImageUsage == 0);
-    m_BufferImageUsage = bufferImageUsage;
-}
-
 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
 {
     json.WriteString("Type");
@@ -12331,7 +10968,7 @@ void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
     json.WriteString("Size");
     json.WriteNumber(m_Size);
     json.WriteString("Usage");
-    json.WriteNumber(m_BufferImageUsage);
+    json.WriteNumber(m_BufferImageUsage.Value); // It may be uint32_t or uint64_t.
 
     if (m_pUserData != VMA_NULL)
     {
@@ -12549,7 +11186,7 @@ VkResult VmaBlockVector::AllocatePage(
                 pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
             if (res == VK_SUCCESS)
             {
-                VMA_DEBUG_LOG_FORMAT("    Returned from last block #%u", pCurrBlock->GetId());
+                VMA_DEBUG_LOG_FORMAT("    Returned from last block #%" PRIu32, pCurrBlock->GetId());
                 IncrementallySortBlocks();
                 return VK_SUCCESS;
             }
@@ -12585,7 +11222,7 @@ VkResult VmaBlockVector::AllocatePage(
                                 pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                             if (res == VK_SUCCESS)
                             {
-                                VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%u", pCurrBlock->GetId());
+                                VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%" PRIu32, pCurrBlock->GetId());
                                 IncrementallySortBlocks();
                                 return VK_SUCCESS;
                             }
@@ -12604,7 +11241,7 @@ VkResult VmaBlockVector::AllocatePage(
                         pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                     if (res == VK_SUCCESS)
                     {
-                        VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%u", pCurrBlock->GetId());
+                        VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%" PRIu32, pCurrBlock->GetId());
                         IncrementallySortBlocks();
                         return VK_SUCCESS;
                     }
@@ -12621,7 +11258,7 @@ VkResult VmaBlockVector::AllocatePage(
                 VkResult res = AllocateFromBlock(pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                 if (res == VK_SUCCESS)
                 {
-                    VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%u", pCurrBlock->GetId());
+                    VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%" PRIu32, pCurrBlock->GetId());
                     IncrementallySortBlocks();
                     return VK_SUCCESS;
                 }
@@ -12688,7 +11325,7 @@ VkResult VmaBlockVector::AllocatePage(
                 pBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
             if (res == VK_SUCCESS)
             {
-                VMA_DEBUG_LOG_FORMAT("    Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
+                VMA_DEBUG_LOG_FORMAT("    Created new block #%" PRIu32 " Size=%" PRIu64, pBlock->GetId(), newBlockSize);
                 IncrementallySortBlocks();
                 return VK_SUCCESS;
             }
@@ -12737,7 +11374,7 @@ void VmaBlockVector::Free(const VmaAllocation hAllocation)
         pBlock->PostFree(m_hAllocator);
         VMA_HEAVY_ASSERT(pBlock->Validate());
 
-        VMA_DEBUG_LOG_FORMAT("  Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
+        VMA_DEBUG_LOG_FORMAT("  Freed from MemoryTypeIndex=%" PRIu32, m_MemoryTypeIndex);
 
         const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
         // pBlock became empty after this deallocation.
@@ -12770,7 +11407,7 @@ void VmaBlockVector::Free(const VmaAllocation hAllocation)
     // lock, for performance reason.
     if (pBlockToDelete != VMA_NULL)
     {
-        VMA_DEBUG_LOG_FORMAT("    Deleted empty block #%u", pBlockToDelete->GetId());
+        VMA_DEBUG_LOG_FORMAT("    Deleted empty block #%" PRIu32, pBlockToDelete->GetId());
         pBlockToDelete->Destroy(m_hAllocator);
         vma_delete(m_hAllocator, pBlockToDelete);
     }
@@ -12817,7 +11454,7 @@ void VmaBlockVector::IncrementallySortBlocks()
         {
             if (m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
             {
-                VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
+                std::swap(m_Blocks[i - 1], m_Blocks[i]);
                 return;
             }
         }
@@ -13354,13 +11991,13 @@ VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMo
                             {
                                 if (vector->GetBlock(i) == block.block)
                                 {
-                                    VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[vector->GetBlockCount() - ++m_ImmovableBlockCount]);
+                                    std::swap(vector->m_Blocks[i], vector->m_Blocks[vector->GetBlockCount() - ++m_ImmovableBlockCount]);
                                     if (state.firstFreeBlock != SIZE_MAX)
                                     {
                                         if (i + 1 < state.firstFreeBlock)
                                         {
                                             if (state.firstFreeBlock > 1)
-                                                VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[--state.firstFreeBlock]);
+                                                std::swap(vector->m_Blocks[i], vector->m_Blocks[--state.firstFreeBlock]);
                                             else
                                                 --state.firstFreeBlock;
                                         }
@@ -13387,7 +12024,7 @@ VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMo
                 {
                     if (vector->GetBlock(i) == block.block)
                     {
-                        VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[m_ImmovableBlockCount++]);
+                        std::swap(vector->m_Blocks[i], vector->m_Blocks[m_ImmovableBlockCount++]);
                         break;
                     }
                 }
@@ -14074,6 +12711,8 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
     m_UseAmdDeviceCoherentMemory((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT) != 0),
     m_UseKhrBufferDeviceAddress((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT) != 0),
     m_UseExtMemoryPriority((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT) != 0),
+    m_UseKhrMaintenance4((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT) != 0),
+    m_UseKhrMaintenance5((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT) != 0),
     m_hDevice(pCreateInfo->device),
     m_hInstance(pCreateInfo->instance),
     m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
@@ -14153,6 +12792,18 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
         VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
     }
 #endif
+#if !(VMA_KHR_MAINTENANCE4)
+    if(m_UseKhrMaintenance4)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
+    }
+#endif
+#if !(VMA_KHR_MAINTENANCE5)
+    if(m_UseKhrMaintenance5)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
+    }
+#endif
 
     memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
     memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
@@ -14231,7 +12882,7 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
                 GetMemoryTypeMinAlignment(memTypeIndex), // minAllocationAlignment
                 VMA_NULL); // // pMemoryAllocateNext
             // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
-            // becase minBlockCount is 0.
+            // because minBlockCount is 0.
         }
     }
 }
@@ -14314,7 +12965,7 @@ void VmaAllocator_T::ImportVulkanFunctions_Static()
     }
 #endif
 
-#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
+#if VMA_VULKAN_VERSION >= 1001000
     if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
     {
         m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2)vkGetPhysicalDeviceMemoryProperties2;
@@ -14373,7 +13024,7 @@ void VmaAllocator_T::ImportVulkanFunctions_Custom(const VmaVulkanFunctions* pVul
     VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
 #endif
 
-#if VMA_VULKAN_VERSION >= 1003000
+#if VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
     VMA_COPY_IF_NOT_NULL(vkGetDeviceBufferMemoryRequirements);
     VMA_COPY_IF_NOT_NULL(vkGetDeviceImageMemoryRequirements);
 #endif
@@ -14430,11 +13081,11 @@ void VmaAllocator_T::ImportVulkanFunctions_Dynamic()
 #if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
     if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
     {
-        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2");
+        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2");
     }
     else if(m_UseExtMemoryBudget)
     {
-        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2KHR");
+        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2KHR");
     }
 #endif
 
@@ -14472,6 +13123,13 @@ void VmaAllocator_T::ImportVulkanFunctions_Dynamic()
         VMA_FETCH_DEVICE_FUNC(vkGetDeviceImageMemoryRequirements, PFN_vkGetDeviceImageMemoryRequirements, "vkGetDeviceImageMemoryRequirements");
     }
 #endif
+#if VMA_KHR_MAINTENANCE4
+    if(m_UseKhrMaintenance4)
+    {
+        VMA_FETCH_DEVICE_FUNC(vkGetDeviceBufferMemoryRequirements, PFN_vkGetDeviceBufferMemoryRequirementsKHR, "vkGetDeviceBufferMemoryRequirementsKHR");
+        VMA_FETCH_DEVICE_FUNC(vkGetDeviceImageMemoryRequirements, PFN_vkGetDeviceImageMemoryRequirementsKHR, "vkGetDeviceImageMemoryRequirementsKHR");
+    }
+#endif
 
 #undef VMA_FETCH_DEVICE_FUNC
 #undef VMA_FETCH_INSTANCE_FUNC
@@ -14522,13 +13180,12 @@ void VmaAllocator_T::ValidateVulkanFunctions()
     }
 #endif
 
-#if VMA_VULKAN_VERSION >= 1003000
-    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
-    {
-        VMA_ASSERT(m_VulkanFunctions.vkGetDeviceBufferMemoryRequirements != VMA_NULL);
-        VMA_ASSERT(m_VulkanFunctions.vkGetDeviceImageMemoryRequirements != VMA_NULL);
-    }
-#endif
+    // Not validating these due to suspected driver bugs with these function
+    // pointers being null despite correct extension or Vulkan version is enabled.
+    // See issue #397. Their usage in VMA is optional anyway.
+    //
+    // VMA_ASSERT(m_VulkanFunctions.vkGetDeviceBufferMemoryRequirements != VMA_NULL);
+    // VMA_ASSERT(m_VulkanFunctions.vkGetDeviceImageMemoryRequirements != VMA_NULL);
 }
 
 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
@@ -14546,7 +13203,7 @@ VkResult VmaAllocator_T::AllocateMemoryOfType(
     bool dedicatedPreferred,
     VkBuffer dedicatedBuffer,
     VkImage dedicatedImage,
-    VkFlags dedicatedBufferImageUsage,
+    VmaBufferImageUsage dedicatedBufferImageUsage,
     const VmaAllocationCreateInfo& createInfo,
     uint32_t memTypeIndex,
     VmaSuballocationType suballocType,
@@ -14556,7 +13213,7 @@ VkResult VmaAllocator_T::AllocateMemoryOfType(
     VmaAllocation* pAllocations)
 {
     VMA_ASSERT(pAllocations != VMA_NULL);
-    VMA_DEBUG_LOG_FORMAT("  AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);
+    VMA_DEBUG_LOG_FORMAT("  AllocateMemory: MemoryTypeIndex=%" PRIu32 ", AllocationCount=%zu, Size=%" PRIu64, memTypeIndex, allocationCount, size);
 
     VmaAllocationCreateInfo finalCreateInfo = createInfo;
     VkResult res = CalcMemTypeParams(
@@ -14700,7 +13357,7 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
     float priority,
     VkBuffer dedicatedBuffer,
     VkImage dedicatedImage,
-    VkFlags dedicatedBufferImageUsage,
+    VmaBufferImageUsage dedicatedBufferImageUsage,
     size_t allocationCount,
     VmaAllocation* pAllocations,
     const void* pNextChain)
@@ -14740,8 +13397,8 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
         bool canContainBufferWithDeviceAddress = true;
         if(dedicatedBuffer != VK_NULL_HANDLE)
         {
-            canContainBufferWithDeviceAddress = dedicatedBufferImageUsage == UINT32_MAX || // Usage flags unknown
-                (dedicatedBufferImageUsage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) != 0;
+            canContainBufferWithDeviceAddress = dedicatedBufferImageUsage == VmaBufferImageUsage::UNKNOWN ||
+                dedicatedBufferImageUsage.Contains(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT);
         }
         else if(dedicatedImage != VK_NULL_HANDLE)
         {
@@ -14802,7 +13459,7 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
         {
             dedicatedAllocations.Register(pAllocations[allocIndex]);
         }
-        VMA_DEBUG_LOG_FORMAT("    Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
+        VMA_DEBUG_LOG_FORMAT("    Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%" PRIu32, allocationCount, memTypeIndex);
     }
     else
     {
@@ -14953,7 +13610,7 @@ void VmaAllocator_T::GetImageMemoryRequirements(
 VkResult VmaAllocator_T::FindMemoryTypeIndex(
     uint32_t memoryTypeBits,
     const VmaAllocationCreateInfo* pAllocationCreateInfo,
-    VkFlags bufImgUsage,
+    VmaBufferImageUsage bufImgUsage,
     uint32_t* pMemoryTypeIndex) const
 {
     memoryTypeBits &= GetGlobalMemoryTypeBits();
@@ -15108,7 +13765,7 @@ VkResult VmaAllocator_T::AllocateMemory(
     bool prefersDedicatedAllocation,
     VkBuffer dedicatedBuffer,
     VkImage dedicatedImage,
-    VkFlags dedicatedBufferImageUsage,
+    VmaBufferImageUsage dedicatedBufferImageUsage,
     const VmaAllocationCreateInfo& createInfo,
     VmaSuballocationType suballocType,
     size_t allocationCount,
@@ -15379,7 +14036,7 @@ void VmaAllocator_T::GetAllocationInfo2(VmaAllocation hAllocation, VmaAllocation
 
 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
 {
-    VMA_DEBUG_LOG_FORMAT("  CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
+    VMA_DEBUG_LOG_FORMAT("  CreatePool: MemoryTypeIndex=%" PRIu32 ", flags=%" PRIu32, pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
 
     VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
 
@@ -15680,7 +14337,6 @@ VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
             }
             return res;
         }
-        VMA_FALLTHROUGH; // Fallthrough
     case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
         return hAllocation->DedicatedAllocMap(this, ppData);
     default:
@@ -15714,7 +14370,7 @@ VkResult VmaAllocator_T::BindBufferMemory(
     VkBuffer hBuffer,
     const void* pNext)
 {
-    VkResult res = VK_ERROR_UNKNOWN;
+    VkResult res = VK_ERROR_UNKNOWN_COPY;
     switch(hAllocation->GetType())
     {
     case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
@@ -15739,7 +14395,7 @@ VkResult VmaAllocator_T::BindImageMemory(
     VkImage hImage,
     const void* pNext)
 {
-    VkResult res = VK_ERROR_UNKNOWN;
+    VkResult res = VK_ERROR_UNKNOWN_COPY;
     switch(hAllocation->GetType())
     {
     case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
@@ -15825,6 +14481,43 @@ VkResult VmaAllocator_T::FlushOrInvalidateAllocations(
     return res;
 }
 
+VkResult VmaAllocator_T::CopyMemoryToAllocation(
+    const void* pSrcHostPointer,
+    VmaAllocation dstAllocation,
+    VkDeviceSize dstAllocationLocalOffset,
+    VkDeviceSize size)
+{
+    void* dstMappedData = VMA_NULL;
+    VkResult res = Map(dstAllocation, &dstMappedData);
+    if(res == VK_SUCCESS)
+    {
+        memcpy((char*)dstMappedData + dstAllocationLocalOffset, pSrcHostPointer, (size_t)size);
+        Unmap(dstAllocation);
+        res = FlushOrInvalidateAllocation(dstAllocation, dstAllocationLocalOffset, size, VMA_CACHE_FLUSH);
+    }
+    return res;
+}
+
+VkResult VmaAllocator_T::CopyAllocationToMemory(
+    VmaAllocation srcAllocation,
+    VkDeviceSize srcAllocationLocalOffset,
+    void* pDstHostPointer,
+    VkDeviceSize size)
+{
+    void* srcMappedData = VMA_NULL;
+    VkResult res = Map(srcAllocation, &srcMappedData);
+    if(res == VK_SUCCESS)
+    {
+        res = FlushOrInvalidateAllocation(srcAllocation, srcAllocationLocalOffset, size, VMA_CACHE_INVALIDATE);
+        if(res == VK_SUCCESS)
+        {
+            memcpy(pDstHostPointer, (const char*)srcMappedData + srcAllocationLocalOffset, (size_t)size);
+            Unmap(srcAllocation);
+        }
+    }
+    return res;
+}
+
 void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
 {
     VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
@@ -15859,7 +14552,7 @@ void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
     m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
     m_AllocationObjectAllocator.Free(allocation);
 
-    VMA_DEBUG_LOG_FORMAT("    Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
+    VMA_DEBUG_LOG_FORMAT("    Freed DedicatedMemory MemoryTypeIndex=%" PRIu32, memTypeIndex);
 }
 
 uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
@@ -16444,7 +15137,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
     VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
     VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
 
-    return allocator->FindMemoryTypeIndex(memoryTypeBits, pAllocationCreateInfo, UINT32_MAX, pMemoryTypeIndex);
+    return allocator->FindMemoryTypeIndex(memoryTypeBits, pAllocationCreateInfo, VmaBufferImageUsage::UNKNOWN, pMemoryTypeIndex);
 }
 
 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
@@ -16462,21 +15155,22 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
     const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
     VkResult res;
 
-#if VMA_VULKAN_VERSION >= 1003000
+#if VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
     if(funcs->vkGetDeviceBufferMemoryRequirements)
     {
         // Can query straight from VkBufferCreateInfo :)
-        VkDeviceBufferMemoryRequirements devBufMemReq = {VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS};
+        VkDeviceBufferMemoryRequirementsKHR devBufMemReq = {VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR};
         devBufMemReq.pCreateInfo = pBufferCreateInfo;
 
         VkMemoryRequirements2 memReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
         (*funcs->vkGetDeviceBufferMemoryRequirements)(hDev, &devBufMemReq, &memReq);
 
         res = allocator->FindMemoryTypeIndex(
-            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);
+            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo,
+            VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), pMemoryTypeIndex);
     }
     else
-#endif // #if VMA_VULKAN_VERSION >= 1003000
+#endif // VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
     {
         // Must create a dummy buffer to query :(
         VkBuffer hBuffer = VK_NULL_HANDLE;
@@ -16488,7 +15182,8 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
             funcs->vkGetBufferMemoryRequirements(hDev, hBuffer, &memReq);
 
             res = allocator->FindMemoryTypeIndex(
-                memReq.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);
+                memReq.memoryTypeBits, pAllocationCreateInfo,
+                VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), pMemoryTypeIndex);
 
             funcs->vkDestroyBuffer(
                 hDev, hBuffer, allocator->GetAllocationCallbacks());
@@ -16512,11 +15207,11 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
     const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
     VkResult res;
 
-#if VMA_VULKAN_VERSION >= 1003000
+#if VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
     if(funcs->vkGetDeviceImageMemoryRequirements)
     {
         // Can query straight from VkImageCreateInfo :)
-        VkDeviceImageMemoryRequirements devImgMemReq = {VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS};
+        VkDeviceImageMemoryRequirementsKHR devImgMemReq = {VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR};
         devImgMemReq.pCreateInfo = pImageCreateInfo;
         VMA_ASSERT(pImageCreateInfo->tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT_COPY && (pImageCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT_COPY) == 0 &&
             "Cannot use this VkImageCreateInfo with vmaFindMemoryTypeIndexForImageInfo as I don't know what to pass as VkDeviceImageMemoryRequirements::planeAspect.");
@@ -16525,10 +15220,11 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
         (*funcs->vkGetDeviceImageMemoryRequirements)(hDev, &devImgMemReq, &memReq);
 
         res = allocator->FindMemoryTypeIndex(
-            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);
+            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo,
+            VmaBufferImageUsage(*pImageCreateInfo), pMemoryTypeIndex);
     }
     else
-#endif // #if VMA_VULKAN_VERSION >= 1003000
+#endif // VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
     {
         // Must create a dummy image to query :(
         VkImage hImage = VK_NULL_HANDLE;
@@ -16540,7 +15236,8 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
             funcs->vkGetImageMemoryRequirements(hDev, hImage, &memReq);
 
             res = allocator->FindMemoryTypeIndex(
-                memReq.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);
+                memReq.memoryTypeBits, pAllocationCreateInfo,
+                VmaBufferImageUsage(*pImageCreateInfo), pMemoryTypeIndex);
 
             funcs->vkDestroyImage(
                 hDev, hImage, allocator->GetAllocationCallbacks());
@@ -16663,7 +15360,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
         false, // prefersDedicatedAllocation
         VK_NULL_HANDLE, // dedicatedBuffer
         VK_NULL_HANDLE, // dedicatedImage
-        UINT32_MAX, // dedicatedBufferImageUsage
+        VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
         *pCreateInfo,
         VMA_SUBALLOCATION_TYPE_UNKNOWN,
         1, // allocationCount
@@ -16702,7 +15399,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
         false, // prefersDedicatedAllocation
         VK_NULL_HANDLE, // dedicatedBuffer
         VK_NULL_HANDLE, // dedicatedImage
-        UINT32_MAX, // dedicatedBufferImageUsage
+        VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
         *pCreateInfo,
         VMA_SUBALLOCATION_TYPE_UNKNOWN,
         allocationCount,
@@ -16745,7 +15442,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
         prefersDedicatedAllocation,
         buffer, // dedicatedBuffer
         VK_NULL_HANDLE, // dedicatedImage
-        UINT32_MAX, // dedicatedBufferImageUsage
+        VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
         *pCreateInfo,
         VMA_SUBALLOCATION_TYPE_BUFFER,
         1, // allocationCount
@@ -16784,7 +15481,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
         prefersDedicatedAllocation,
         VK_NULL_HANDLE, // dedicatedBuffer
         image, // dedicatedImage
-        UINT32_MAX, // dedicatedBufferImageUsage
+        VmaBufferImageUsage::UNKNOWN, // dedicatedBufferImageUsage
         *pCreateInfo,
         VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
         1, // allocationCount
@@ -16926,9 +15623,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocation(
 
     VMA_DEBUG_GLOBAL_MUTEX_LOCK
 
-    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
-
-    return res;
+    return allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
 }
 
 VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(
@@ -16943,9 +15638,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(
 
     VMA_DEBUG_GLOBAL_MUTEX_LOCK
 
-    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
-
-    return res;
+    return allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
 }
 
 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
@@ -16968,9 +15661,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
 
     VMA_DEBUG_GLOBAL_MUTEX_LOCK
 
-    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_FLUSH);
-
-    return res;
+    return allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_FLUSH);
 }
 
 VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
@@ -16993,9 +15684,49 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
 
     VMA_DEBUG_GLOBAL_MUTEX_LOCK
 
-    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_INVALIDATE);
+    return allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_INVALIDATE);
+}
 
-    return res;
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCopyMemoryToAllocation(
+    VmaAllocator allocator,
+    const void* pSrcHostPointer,
+    VmaAllocation dstAllocation,
+    VkDeviceSize dstAllocationLocalOffset,
+    VkDeviceSize size)
+{
+    VMA_ASSERT(allocator && pSrcHostPointer && dstAllocation);
+
+    if(size == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_DEBUG_LOG("vmaCopyMemoryToAllocation");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->CopyMemoryToAllocation(pSrcHostPointer, dstAllocation, dstAllocationLocalOffset, size);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCopyAllocationToMemory(
+    VmaAllocator allocator,
+    VmaAllocation srcAllocation,
+    VkDeviceSize srcAllocationLocalOffset,
+    void* pDstHostPointer,
+    VkDeviceSize size)
+{
+    VMA_ASSERT(allocator && srcAllocation && pDstHostPointer);
+
+    if(size == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_DEBUG_LOG("vmaCopyAllocationToMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->CopyAllocationToMemory(srcAllocation, srcAllocationLocalOffset, pDstHostPointer, size);
 }
 
 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(
@@ -17187,7 +15918,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
             prefersDedicatedAllocation,
             *pBuffer, // dedicatedBuffer
             VK_NULL_HANDLE, // dedicatedImage
-            pBufferCreateInfo->usage, // dedicatedBufferImageUsage
+            VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), // dedicatedBufferImageUsage
             *pAllocationCreateInfo,
             VMA_SUBALLOCATION_TYPE_BUFFER,
             1, // allocationCount
@@ -17204,7 +15935,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
             {
                 // All steps succeeded.
                 #if VMA_STATS_STRING_ENABLED
-                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
+                    (*pAllocation)->InitBufferUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5);
                 #endif
                 if(pAllocationInfo != VMA_NULL)
                 {
@@ -17282,7 +16013,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
             prefersDedicatedAllocation,
             *pBuffer, // dedicatedBuffer
             VK_NULL_HANDLE, // dedicatedImage
-            pBufferCreateInfo->usage, // dedicatedBufferImageUsage
+            VmaBufferImageUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5), // dedicatedBufferImageUsage
             *pAllocationCreateInfo,
             VMA_SUBALLOCATION_TYPE_BUFFER,
             1, // allocationCount
@@ -17299,7 +16030,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
             {
                 // All steps succeeded.
                 #if VMA_STATS_STRING_ENABLED
-                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
+                    (*pAllocation)->InitBufferUsage(*pBufferCreateInfo, allocator->m_UseKhrMaintenance5);
                 #endif
                 if(pAllocationInfo != VMA_NULL)
                 {
@@ -17458,7 +16189,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
             prefersDedicatedAllocation,
             VK_NULL_HANDLE, // dedicatedBuffer
             *pImage, // dedicatedImage
-            pImageCreateInfo->usage, // dedicatedBufferImageUsage
+            VmaBufferImageUsage(*pImageCreateInfo), // dedicatedBufferImageUsage
             *pAllocationCreateInfo,
             suballocType,
             1, // allocationCount
@@ -17475,7 +16206,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
             {
                 // All steps succeeded.
                 #if VMA_STATS_STRING_ENABLED
-                    (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
+                    (*pAllocation)->InitImageUsage(*pImageCreateInfo);
                 #endif
                 if(pAllocationInfo != VMA_NULL)
                 {
@@ -17714,13 +16445,14 @@ VMA_CALL_PRE void VMA_CALL_POST vmaFreeVirtualBlockStatsString(VmaVirtualBlock V
 \section quick_start_project_setup Project setup
 
 Vulkan Memory Allocator comes in form of a "stb-style" single header file.
-You don't need to build it as a separate library project.
-You can add this file directly to your project and submit it to code repository next to your other source files.
+While you can pull the entire repository e.g. as Git module, there is also Cmake script provided,
+you don't need to build it as a separate library project.
+You can add file "vk_mem_alloc.h" directly to your project and submit it to code repository next to your other source files.
 
 "Single header" doesn't mean that everything is contained in C/C++ declarations,
 like it tends to be in case of inline functions or C++ templates.
 It means that implementation is bundled with interface in a single file and needs to be extracted using preprocessor macro.
-If you don't do it properly, you will get linker errors.
+If you don't do it properly, it will result in linker errors.
 
 To do it properly:
 
@@ -17734,33 +16466,46 @@ To do it properly:
 #include "vk_mem_alloc.h"
 \endcode
 
-It may be a good idea to create dedicated CPP file just for this purpose.
+It may be a good idea to create dedicated CPP file just for this purpose, e.g. "VmaUsage.cpp".
 
 This library includes header `<vulkan/vulkan.h>`, which in turn
 includes `<windows.h>` on Windows. If you need some specific macros defined
 before including these headers (like `WIN32_LEAN_AND_MEAN` or
 `WINVER` for Windows, `VK_USE_PLATFORM_WIN32_KHR` for Vulkan), you must define
 them before every `#include` of this library.
+It may be a good idea to create a dedicate header file for this purpose, e.g. "VmaUsage.h",
+that will be included in other source files instead of VMA header directly.
 
 This library is written in C++, but has C-compatible interface.
-Thus you can include and use vk_mem_alloc.h in C or C++ code, but full
+Thus, you can include and use "vk_mem_alloc.h" in C or C++ code, but full
 implementation with `VMA_IMPLEMENTATION` macro must be compiled as C++, NOT as C.
-Some features of C++14 are used. STL containers, RTTI, or C++ exceptions are not used.
+Some features of C++14 are used and required. Features of C++20 are used optionally when available.
+Some headers of standard C and C++ library are used, but STL containers, RTTI, or C++ exceptions are not used.
 
 
 \section quick_start_initialization Initialization
 
+VMA offers library interface in a style similar to Vulkan, with object handles like #VmaAllocation,
+structures describing parameters of objects to be created like #VmaAllocationCreateInfo,
+and errors codes returned from functions using `VkResult` type.
+
+The first and the main object that needs to be created is #VmaAllocator.
+It represents the initialization of the entire library.
+Only one such object should be created per `VkDevice`.
+You should create it at program startup, after `VkDevice` was created, and before any device memory allocator needs to be made.
+It must be destroyed before `VkDevice` is destroyed.
+
 At program startup:
 
--# Initialize Vulkan to have `VkPhysicalDevice`, `VkDevice` and `VkInstance` object.
--# Fill VmaAllocatorCreateInfo structure and create #VmaAllocator object by
-   calling vmaCreateAllocator().
+-# Initialize Vulkan to have `VkInstance`, `VkPhysicalDevice`, `VkDevice` object.
+-# Fill VmaAllocatorCreateInfo structure and call vmaCreateAllocator() to create #VmaAllocator object.
 
 Only members `physicalDevice`, `device`, `instance` are required.
 However, you should inform the library which Vulkan version do you use by setting
 VmaAllocatorCreateInfo::vulkanApiVersion and which extensions did you enable
-by setting VmaAllocatorCreateInfo::flags (like #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT for VK_KHR_buffer_device_address).
+by setting VmaAllocatorCreateInfo::flags.
 Otherwise, VMA would use only features of Vulkan 1.0 core with no extensions.
+See below for details.
 
 \subsection quick_start_initialization_selecting_vulkan_version Selecting Vulkan version
 
@@ -17806,7 +16551,25 @@ You may need to configure importing Vulkan functions. There are 3 ways to do thi
    - Define `VMA_STATIC_VULKAN_FUNCTIONS` and `VMA_DYNAMIC_VULKAN_FUNCTIONS` to 0.
    - Pass these pointers via structure #VmaVulkanFunctions.
 
-Example for case 2:
+\subsection quick_start_initialization_enabling_extensions Enabling extensions
+
+VMA can automatically use following Vulkan extensions.
+If you found them available on the selected physical device and you enabled them
+while creating `VkInstance` / `VkDevice` object, inform VMA about their availability
+by setting appropriate flags in VmaAllocatorCreateInfo::flags.
+
+Vulkan extension              | VMA flag
+------------------------------|-----------------------------------------------------
+VK_KHR_dedicated_allocation   | #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
+VK_KHR_bind_memory2           | #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT
+VK_KHR_maintenance4           | #VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT
+VK_KHR_maintenance5           | #VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE5_BIT
+VK_EXT_memory_budget          | #VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT
+VK_KHR_buffer_device_address  | #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT
+VK_EXT_memory_priority        | #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT
+VK_AMD_device_coherent_memory | #VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT
+
+Example with fetching pointers to Vulkan functions dynamically:
 
 \code
 #define VMA_STATIC_VULKAN_FUNCTIONS 0
@@ -17820,6 +16583,7 @@ vulkanFunctions.vkGetInstanceProcAddr = &vkGetInstanceProcAddr;
 vulkanFunctions.vkGetDeviceProcAddr = &vkGetDeviceProcAddr;
 
 VmaAllocatorCreateInfo allocatorCreateInfo = {};
+allocatorCreateInfo.flags = VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT;
 allocatorCreateInfo.vulkanApiVersion = VK_API_VERSION_1_2;
 allocatorCreateInfo.physicalDevice = physicalDevice;
 allocatorCreateInfo.device = device;
@@ -17828,9 +16592,24 @@ allocatorCreateInfo.pVulkanFunctions = &vulkanFunctions;
 
 VmaAllocator allocator;
 vmaCreateAllocator(&allocatorCreateInfo, &allocator);
+
+// Entire program...
+
+// At the end, don't forget to:
+vmaDestroyAllocator(allocator);
 \endcode
 
 
+\subsection quick_start_initialization_other_config Other configuration options
+
+There are additional configuration options available through preprocessor macros that you can define
+before including VMA header and through parameters passed in #VmaAllocatorCreateInfo.
+They include a possibility to use your own callbacks for host memory allocations (`VkAllocationCallbacks`),
+callbacks for device memory allocations (instead of `vkAllocateMemory`, `vkFreeMemory`),
+or your custom `VMA_ASSERT` macro, among others.
+For more information, see: @ref configuration.
+
+
 \section quick_start_resource_allocation Resource allocation
 
 When you want to create a buffer or image:
@@ -17853,13 +16632,19 @@ VmaAllocation allocation;
 vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
 \endcode
 
-Don't forget to destroy your objects when no longer needed:
+Don't forget to destroy your buffer and allocation objects when no longer needed:
 
 \code
 vmaDestroyBuffer(allocator, buffer, allocation);
-vmaDestroyAllocator(allocator);
 \endcode
 
+If you need to map the buffer, you must set flag
+#VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
+in VmaAllocationCreateInfo::flags.
+There are many additional parameters that can control the choice of memory type to be used for the allocation
+and other features.
+For more information, see documentation chapters: @ref choosing_memory_type, @ref memory_mapping.
+
 
 \page choosing_memory_type Choosing memory type
 
@@ -17882,10 +16667,10 @@ You can also combine multiple methods.
    vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage().
    For binding you should use functions: vmaBindBufferMemory(), vmaBindImageMemory()
    or their extended versions: vmaBindBufferMemory2(), vmaBindImageMemory2().
--# **This is the easiest and recommended way to use this library:**
-   If you want to create a buffer or an image, allocate memory for it and bind
+-# If you want to create a buffer or an image, allocate memory for it, and bind
    them together, all in one call, you can use function vmaCreateBuffer(),
    vmaCreateImage().
+   <b>This is the easiest and recommended way to use this library!</b>
 
 When using 3. or 4., the library internally queries Vulkan for memory types
 supported for that buffer or image (function `vkGetBufferMemoryRequirements()`)
@@ -17953,6 +16738,7 @@ vmaCreateBuffer(allocator, &stagingBufferInfo, &stagingAllocInfo, &stagingBuffer
 \endcode
 
 For more examples of creating different kinds of resources, see chapter \ref usage_patterns.
+See also: @ref memory_mapping.
 
 Usage values `VMA_MEMORY_USAGE_AUTO*` are legal to use only when the library knows
 about the resource being created by having `VkBufferCreateInfo` / `VkImageCreateInfo` passed,
@@ -17964,7 +16750,7 @@ memory type, as described below.
 Old usage values (`VMA_MEMORY_USAGE_GPU_ONLY`, `VMA_MEMORY_USAGE_CPU_ONLY`,
 `VMA_MEMORY_USAGE_CPU_TO_GPU`, `VMA_MEMORY_USAGE_GPU_TO_CPU`, `VMA_MEMORY_USAGE_CPU_COPY`)
 are still available and work same way as in previous versions of the library
-for backward compatibility, but they are not recommended.
+for backward compatibility, but they are deprecated.
 
 \section choosing_memory_type_required_preferred_flags Required and preferred flags
 
@@ -17994,8 +16780,8 @@ plus some extra "magic" (heuristics).
 
 \section choosing_memory_type_explicit_memory_types Explicit memory types
 
-If you inspected memory types available on the physical device and you have
-a preference for memory types that you want to use, you can fill member
+If you inspected memory types available on the physical device and <b>you have
+a preference for memory types that you want to use</b>, you can fill member
 VmaAllocationCreateInfo::memoryTypeBits. It is a bit mask, where each bit set
 means that a memory type with that index is allowed to be used for the
 allocation. Special value 0, just like `UINT32_MAX`, means there are no
@@ -18017,6 +16803,21 @@ VmaAllocation allocation;
 vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
 \endcode
 
+You can also use this parameter to <b>exclude some memory types</b>.
+If you inspect memory heaps and types available on the current physical device and
+you determine that for some reason you don't want to use a specific memory type for the allocation,
+you can enable automatic memory type selection but exclude certain memory type or types
+by setting all bits of `memoryTypeBits` to 1 except the ones you choose.
+
+\code
+// ...
+uint32_t excludedMemoryTypeIndex = 2;
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocInfo.memoryTypeBits = ~(1u << excludedMemoryTypeIndex);
+// ...
+\endcode
+
 
 \section choosing_memory_type_custom_memory_pools Custom memory pools
 
@@ -18055,6 +16856,7 @@ You can use them directly with memory allocated by this library,
 but it is not recommended because of following issue:
 Mapping the same `VkDeviceMemory` block multiple times is illegal - only one mapping at a time is allowed.
 This includes mapping disjoint regions. Mapping is not reference-counted internally by Vulkan.
+It is also not thread-safe.
 Because of this, Vulkan Memory Allocator provides following facilities:
 
 \note If you want to be able to map an allocation, you need to specify one of the flags
@@ -18062,11 +16864,44 @@ Because of this, Vulkan Memory Allocator provides following facilities:
 in VmaAllocationCreateInfo::flags. These flags are required for an allocation to be mappable
 when using #VMA_MEMORY_USAGE_AUTO or other `VMA_MEMORY_USAGE_AUTO*` enum values.
 For other usage values they are ignored and every such allocation made in `HOST_VISIBLE` memory type is mappable,
-but they can still be used for consistency.
+but these flags can still be used for consistency.
+
+\section memory_mapping_copy_functions Copy functions
+
+The easiest way to copy data from a host pointer to an allocation is to use convenience function vmaCopyMemoryToAllocation().
+It automatically maps the Vulkan memory temporarily (if not already mapped), performs `memcpy`,
+and calls `vkFlushMappedMemoryRanges` (if required - if memory type is not `HOST_COHERENT`).
+
+It is also the safest one, because using `memcpy` avoids a risk of accidentally introducing memory reads
+(e.g. by doing `pMappedVectors[i] += v`), which may be very slow on memory types that are not `HOST_CACHED`.
+
+\code
+struct ConstantBuffer
+{
+    ...
+};
+ConstantBuffer constantBufferData = ...
+
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = sizeof(ConstantBuffer);
+bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
+
+VkBuffer buf;
+VmaAllocation alloc;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, nullptr);
+
+vmaCopyMemoryToAllocation(allocator, &constantBufferData, alloc, 0, sizeof(ConstantBuffer));
+\endcode
+
+Copy in the other direction - from an allocation to a host pointer can be performed the same way using function vmaCopyAllocationToMemory().
 
 \section memory_mapping_mapping_functions Mapping functions
 
-The library provides following functions for mapping of a specific #VmaAllocation: vmaMapMemory(), vmaUnmapMemory().
+The library provides following functions for mapping of a specific allocation: vmaMapMemory(), vmaUnmapMemory().
 They are safer and more convenient to use than standard Vulkan functions.
 You can map an allocation multiple times simultaneously - mapping is reference-counted internally.
 You can also map different allocations simultaneously regardless of whether they use the same `VkDeviceMemory` block.
@@ -18362,6 +17197,7 @@ A memory pool contains a number of `VkDeviceMemory` blocks.
 The library automatically creates and manages default pool for each memory type available on the device.
 Default memory pool automatically grows in size.
 Size of allocated blocks is also variable and managed automatically.
+You are using default pools whenever you leave VmaAllocationCreateInfo::pool = null.
 
 You can create custom pool and allocate memory out of it.
 It can be useful if you want to:
@@ -18433,13 +17269,6 @@ It is supported only when VmaPoolCreateInfo::blockSize = 0.
 To use this feature, set VmaAllocationCreateInfo::pool to the pointer to your custom pool and
 VmaAllocationCreateInfo::flags to #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
 
-\note Excessive use of custom pools is a common mistake when using this library.
-Custom pools may be useful for special purposes - when you want to
-keep certain type of resources separate e.g. to reserve minimum amount of memory
-for them or limit maximum amount of memory they can occupy. For most
-resources this is not needed and so it is not recommended to create #VmaPool
-objects and allocations out of them. Allocating from the default pool is sufficient.
-
 
 \section custom_memory_pools_MemTypeIndex Choosing memory type index
 
@@ -18474,6 +17303,51 @@ When creating buffers/images allocated in that pool, provide following parameter
 - VmaAllocationCreateInfo: You don't need to pass same parameters. Fill only `pool` member.
   Other members are ignored anyway.
 
+
+\section custom_memory_pools_when_not_use When not to use custom pools
+
+Custom pools are commonly overused by VMA users.
+While it may feel natural to keep some logical groups of resources separate in memory,
+in most cases it does more harm than good.
+Using custom pool shouldn't be your first choice.
+Instead, please make all allocations from default pools first and only use custom pools
+if you can prove and measure that it is beneficial in some way,
+e.g. it results in lower memory usage, better performance, etc.
+
+Using custom pools has disadvantages:
+
+- Each pool has its own collection of `VkDeviceMemory` blocks.
+  Some of them may be partially or even completely empty.
+  Spreading allocations across multiple pools increases the amount of wasted (allocated but unbound) memory.
+- You must manually choose specific memory type to be used by a custom pool (set as VmaPoolCreateInfo::memoryTypeIndex).
+  When using default pools, best memory type for each of your allocations can be selected automatically
+  using a carefully design algorithm that works across all kinds of GPUs.
+- If an allocation from a custom pool at specific memory type fails, entire allocation operation returns failure.
+  When using default pools, VMA tries another compatible memory type.
+- If you set VmaPoolCreateInfo::blockSize != 0, each memory block has the same size,
+  while default pools start from small blocks and only allocate next blocks larger and larger
+  up to the preferred block size.
+
+Many of the common concerns can be addressed in a different way than using custom pools:
+
+- If you want to keep your allocations of certain size (small versus large) or certain lifetime (transient versus long lived)
+  separate, you likely don't need to.
+  VMA uses a high quality allocation algorithm that manages memory well in various cases.
+  Please measure and check if using custom pools provides a benefit.
+- If you want to keep your images and buffers separate, you don't need to.
+  VMA respects `bufferImageGranularity` limit automatically.
+- If you want to keep your mapped and not mapped allocations separate, you don't need to.
+  VMA respects `nonCoherentAtomSize` limit automatically.
+  It also maps only those `VkDeviceMemory` blocks that need to map any allocation.
+  It even tries to keep mappable and non-mappable allocations in separate blocks to minimize the amount of mapped memory.
+- If you want to choose a custom size for the default memory block, you can set it globally instead
+  using VmaAllocatorCreateInfo::preferredLargeHeapBlockSize.
+- If you want to select specific memory type for your allocation,
+  you can set VmaAllocationCreateInfo::memoryTypeBits to `(1u << myMemoryTypeIndex)` instead.
+- If you need to create a buffer with certain minimum alignment, you can still do it
+  using default pools with dedicated function vmaCreateBufferWithAlignment().
+
+
 \section linear_algorithm Linear allocation algorithm
 
 Each Vulkan memory block managed by this library has accompanying metadata that
@@ -19084,22 +17958,35 @@ Margin validation (corruption detection) works only for memory types that are
 `HOST_VISIBLE` and `HOST_COHERENT`.
 
 
-\page opengl_interop OpenGL Interop
+\section debugging_memory_usage_leak_detection Leak detection features
 
-VMA provides some features that help with interoperability with OpenGL.
+At allocation and allocator destruction time VMA checks for unfreed and unmapped blocks using
+`VMA_ASSERT_LEAK()`. This macro defaults to an assertion, triggering a typically fatal error in Debug
+builds, and doing nothing in Release builds. You can provide your own definition of `VMA_ASSERT_LEAK()`
+to change this behavior.
+
+At memory block destruction time VMA lists out all unfreed allocations using the `VMA_LEAK_LOG_FORMAT()`
+macro, which defaults to `VMA_DEBUG_LOG_FORMAT`, which in turn defaults to a no-op.
+If you're having trouble with leaks - for example, the aforementioned assertion triggers, but you don't
+quite know \em why -, overriding this macro to print out the the leaking blocks, combined with assigning
+individual names to allocations using vmaSetAllocationName(), can greatly aid in fixing them.
+
+\page other_api_interop Interop with other graphics APIs
+
+VMA provides some features that help with interoperability with other graphics APIs, e.g. OpenGL.
 
 \section opengl_interop_exporting_memory Exporting memory
 
-If you want to attach `VkExportMemoryAllocateInfoKHR` structure to `pNext` chain of memory allocations made by the library:
+If you want to attach `VkExportMemoryAllocateInfoKHR` or other structure to `pNext` chain of memory allocations made by the library:
 
-It is recommended to create \ref custom_memory_pools for such allocations.
+You can create \ref custom_memory_pools for such allocations.
 Define and fill in your `VkExportMemoryAllocateInfoKHR` structure and attach it to VmaPoolCreateInfo::pMemoryAllocateNext
 while creating the custom pool.
 Please note that the structure must remain alive and unchanged for the whole lifetime of the #VmaPool,
 not only while creating it, as no copy of the structure is made,
 but its original pointer is used for each allocation instead.
 
-If you want to export all memory allocated by the library from certain memory types,
+If you want to export all memory allocated by VMA from certain memory types,
 also dedicated allocations or other allocations made from default pools,
 an alternative solution is to fill in VmaAllocatorCreateInfo::pTypeExternalMemoryHandleTypes.
 It should point to an array with `VkExternalMemoryHandleTypeFlagsKHR` to be automatically passed by the library
@@ -19116,7 +18003,7 @@ Buffers or images exported to a different API like OpenGL may require a differen
 higher than the one used by the library automatically, queried from functions like `vkGetBufferMemoryRequirements`.
 To impose such alignment:
 
-It is recommended to create \ref custom_memory_pools for such allocations.
+You can create \ref custom_memory_pools for such allocations.
 Set VmaPoolCreateInfo::minAllocationAlignment member to the minimum alignment required for each allocation
 to be made out of this pool.
 The alignment actually used will be the maximum of this member and the alignment returned for the specific buffer or image
@@ -19127,6 +18014,7 @@ use special function vmaCreateBufferWithAlignment(), which takes additional para
 
 Note the problem of alignment affects only resources placed inside bigger `VkDeviceMemory` blocks and not dedicated
 allocations, as these, by definition, always have alignment = 0 because the resource is bound to the beginning of its dedicated block.
+You can ensure that an allocation is created as dedicated by using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
 Contrary to Direct3D 12, Vulkan doesn't have a concept of alignment of the entire memory block passed on its allocation.
 
 \section opengl_interop_extended_allocation_information Extended allocation information
@@ -19306,7 +18194,8 @@ allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
 VkBuffer buf;
 VmaAllocation alloc;
 VmaAllocationInfo allocInfo;
-vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+VkResult result = vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+// Check result...
 
 VkMemoryPropertyFlags memPropFlags;
 vmaGetAllocationMemoryProperties(allocator, alloc, &memPropFlags);
@@ -19317,10 +18206,24 @@ if(memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
 
     // [Executed in runtime]:
     memcpy(allocInfo.pMappedData, myData, myDataSize);
+    result = vmaFlushAllocation(allocator, alloc, 0, VK_WHOLE_SIZE);
+    // Check result...
+
+    VkBufferMemoryBarrier bufMemBarrier = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER };
+    bufMemBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
+    bufMemBarrier.dstAccessMask = VK_ACCESS_UNIFORM_READ_BIT;
+    bufMemBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    bufMemBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    bufMemBarrier.buffer = buf;
+    bufMemBarrier.offset = 0;
+    bufMemBarrier.size = VK_WHOLE_SIZE;
+
+    vkCmdPipelineBarrier(cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+        0, 0, nullptr, 1, &bufMemBarrier, 0, nullptr);
 }
 else
 {
-    // Allocation ended up in a non-mappable memory - need to transfer.
+    // Allocation ended up in a non-mappable memory - a transfer using a staging buffer is required.
     VkBufferCreateInfo stagingBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
     stagingBufCreateInfo.size = 65536;
     stagingBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
@@ -19333,18 +18236,46 @@ else
     VkBuffer stagingBuf;
     VmaAllocation stagingAlloc;
     VmaAllocationInfo stagingAllocInfo;
-    vmaCreateBuffer(allocator, &stagingBufCreateInfo, &stagingAllocCreateInfo,
-        &stagingBuf, &stagingAlloc, stagingAllocInfo);
+    result = vmaCreateBuffer(allocator, &stagingBufCreateInfo, &stagingAllocCreateInfo,
+        &stagingBuf, &stagingAlloc, &stagingAllocInfo);
+    // Check result...
 
     // [Executed in runtime]:
     memcpy(stagingAllocInfo.pMappedData, myData, myDataSize);
-    vmaFlushAllocation(allocator, stagingAlloc, 0, VK_WHOLE_SIZE);
-    //vkCmdPipelineBarrier: VK_ACCESS_HOST_WRITE_BIT --> VK_ACCESS_TRANSFER_READ_BIT
+    result = vmaFlushAllocation(allocator, stagingAlloc, 0, VK_WHOLE_SIZE);
+    // Check result...
+
+    VkBufferMemoryBarrier bufMemBarrier = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER };
+    bufMemBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
+    bufMemBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+    bufMemBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    bufMemBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    bufMemBarrier.buffer = stagingBuf;
+    bufMemBarrier.offset = 0;
+    bufMemBarrier.size = VK_WHOLE_SIZE;
+
+    vkCmdPipelineBarrier(cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+        0, 0, nullptr, 1, &bufMemBarrier, 0, nullptr);
+
     VkBufferCopy bufCopy = {
         0, // srcOffset
         0, // dstOffset,
-        myDataSize); // size
+        myDataSize, // size
+    };
+
     vkCmdCopyBuffer(cmdBuf, stagingBuf, buf, 1, &bufCopy);
+
+    VkBufferMemoryBarrier bufMemBarrier2 = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER };
+    bufMemBarrier2.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+    bufMemBarrier2.dstAccessMask = VK_ACCESS_UNIFORM_READ_BIT; // We created a uniform buffer
+    bufMemBarrier2.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    bufMemBarrier2.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    bufMemBarrier2.buffer = buf;
+    bufMemBarrier2.offset = 0;
+    bufMemBarrier2.size = VK_WHOLE_SIZE;
+
+    vkCmdPipelineBarrier(cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+        0, 0, nullptr, 1, &bufMemBarrier2, 0, nullptr);
 }
 \endcode
 
@@ -19577,7 +18508,7 @@ vmaCreateImage(allocator, &imgCreateInfo, &allocCreateInfo, &img, &alloc, nullpt
 `priority` member is ignored in the following situations:
 
 - Allocations created in custom pools: They inherit the priority, along with all other allocation parameters
-  from the parametrs passed in #VmaPoolCreateInfo when the pool was created.
+  from the parameters passed in #VmaPoolCreateInfo when the pool was created.
 - Allocations created in default pools: They inherit the priority from the parameters
   VMA used when creating default pools, which means `priority == 0.5f`.
 
diff --git a/WickedEngine/Utility/volk.c b/WickedEngine/Utility/volk.c
index 03b648685..b0bc01bee 100644
--- a/WickedEngine/Utility/volk.c
+++ b/WickedEngine/Utility/volk.c
@@ -17,6 +17,10 @@
 #	include <dlfcn.h>
 #endif
 
+#ifdef __APPLE__
+#	include <stdlib.h>
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -27,6 +31,17 @@ __declspec(dllimport) FARPROC __stdcall GetProcAddress(HMODULE, LPCSTR);
 __declspec(dllimport) int __stdcall FreeLibrary(HMODULE);
 #endif
 
+#if defined(__GNUC__)
+#    define VOLK_DISABLE_GCC_PEDANTIC_WARNINGS \
+		_Pragma("GCC diagnostic push") \
+		_Pragma("GCC diagnostic ignored \"-Wpedantic\"")
+#    define VOLK_RESTORE_GCC_PEDANTIC_WARNINGS \
+		_Pragma("GCC diagnostic pop")
+#else
+#    define VOLK_DISABLE_GCC_PEDANTIC_WARNINGS
+#    define VOLK_RESTORE_GCC_PEDANTIC_WARNINGS
+#endif
+
 static void* loadedModule = NULL;
 static VkInstance loadedInstance = VK_NULL_HANDLE;
 static VkDevice loadedDevice = VK_NULL_HANDLE;
@@ -68,6 +83,16 @@ VkResult volkInitialize(void)
 		module = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
 	if (!module)
 		module = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL);
+    // Add support for using Vulkan and MoltenVK in a Framework. App store rules for iOS
+    // strictly enforce no .dylib's. If they aren't found it just falls through
+    if (!module)
+        module = dlopen("vulkan.framework/vulkan", RTLD_NOW | RTLD_LOCAL);
+    if (!module)
+        module = dlopen("MoltenVK.framework/MoltenVK", RTLD_NOW | RTLD_LOCAL);
+	// modern versions of macOS don't search /usr/local/lib automatically contrary to what man dlopen says
+	// Vulkan SDK uses this as the system-wide installation location, so we're going to fallback to this if all else fails
+	if (!module && getenv("DYLD_FALLBACK_LIBRARY_PATH") == NULL)
+		module = dlopen("/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
 	if (!module)
 		return VK_ERROR_INITIALIZATION_FAILED;
 
@@ -78,8 +103,9 @@ VkResult volkInitialize(void)
 		module = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
 	if (!module)
 		return VK_ERROR_INITIALIZATION_FAILED;
-
+	VOLK_DISABLE_GCC_PEDANTIC_WARNINGS
 	vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(module, "vkGetInstanceProcAddr");
+	VOLK_RESTORE_GCC_PEDANTIC_WARNINGS
 #endif
 
 	loadedModule = module;
@@ -276,6 +302,9 @@ static void volkGenLoadInstance(void* context, PFN_vkVoidFunction (*load)(void*,
 #if defined(VK_KHR_android_surface)
 	vkCreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR)load(context, "vkCreateAndroidSurfaceKHR");
 #endif /* defined(VK_KHR_android_surface) */
+#if defined(VK_KHR_calibrated_timestamps)
+	vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = (PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)load(context, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR");
+#endif /* defined(VK_KHR_calibrated_timestamps) */
 #if defined(VK_KHR_cooperative_matrix)
 	vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = (PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)load(context, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR");
 #endif /* defined(VK_KHR_cooperative_matrix) */
@@ -833,6 +862,9 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
 	vkGetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)load(context, "vkGetBufferOpaqueCaptureAddressKHR");
 	vkGetDeviceMemoryOpaqueCaptureAddressKHR = (PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)load(context, "vkGetDeviceMemoryOpaqueCaptureAddressKHR");
 #endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_calibrated_timestamps)
+	vkGetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)load(context, "vkGetCalibratedTimestampsKHR");
+#endif /* defined(VK_KHR_calibrated_timestamps) */
 #if defined(VK_KHR_copy_commands2)
 	vkCmdBlitImage2KHR = (PFN_vkCmdBlitImage2KHR)load(context, "vkCmdBlitImage2KHR");
 	vkCmdCopyBuffer2KHR = (PFN_vkCmdCopyBuffer2KHR)load(context, "vkCmdCopyBuffer2KHR");
@@ -875,6 +907,10 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
 	vkCmdBeginRenderingKHR = (PFN_vkCmdBeginRenderingKHR)load(context, "vkCmdBeginRenderingKHR");
 	vkCmdEndRenderingKHR = (PFN_vkCmdEndRenderingKHR)load(context, "vkCmdEndRenderingKHR");
 #endif /* defined(VK_KHR_dynamic_rendering) */
+#if defined(VK_KHR_dynamic_rendering_local_read)
+	vkCmdSetRenderingAttachmentLocationsKHR = (PFN_vkCmdSetRenderingAttachmentLocationsKHR)load(context, "vkCmdSetRenderingAttachmentLocationsKHR");
+	vkCmdSetRenderingInputAttachmentIndicesKHR = (PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)load(context, "vkCmdSetRenderingInputAttachmentIndicesKHR");
+#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
 #if defined(VK_KHR_external_fence_fd)
 	vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)load(context, "vkGetFenceFdKHR");
 	vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)load(context, "vkImportFenceFdKHR");
@@ -907,6 +943,9 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
 	vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)load(context, "vkGetImageMemoryRequirements2KHR");
 	vkGetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)load(context, "vkGetImageSparseMemoryRequirements2KHR");
 #endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_line_rasterization)
+	vkCmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)load(context, "vkCmdSetLineStippleKHR");
+#endif /* defined(VK_KHR_line_rasterization) */
 #if defined(VK_KHR_maintenance1)
 	vkTrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)load(context, "vkTrimCommandPoolKHR");
 #endif /* defined(VK_KHR_maintenance1) */
@@ -924,6 +963,18 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
 	vkGetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)load(context, "vkGetImageSubresourceLayout2KHR");
 	vkGetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)load(context, "vkGetRenderingAreaGranularityKHR");
 #endif /* defined(VK_KHR_maintenance5) */
+#if defined(VK_KHR_maintenance6)
+	vkCmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)load(context, "vkCmdBindDescriptorSets2KHR");
+	vkCmdPushConstants2KHR = (PFN_vkCmdPushConstants2KHR)load(context, "vkCmdPushConstants2KHR");
+#endif /* defined(VK_KHR_maintenance6) */
+#if defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor)
+	vkCmdPushDescriptorSet2KHR = (PFN_vkCmdPushDescriptorSet2KHR)load(context, "vkCmdPushDescriptorSet2KHR");
+	vkCmdPushDescriptorSetWithTemplate2KHR = (PFN_vkCmdPushDescriptorSetWithTemplate2KHR)load(context, "vkCmdPushDescriptorSetWithTemplate2KHR");
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer)
+	vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = (PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)load(context, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT");
+	vkCmdSetDescriptorBufferOffsets2EXT = (PFN_vkCmdSetDescriptorBufferOffsets2EXT)load(context, "vkCmdSetDescriptorBufferOffsets2EXT");
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer) */
 #if defined(VK_KHR_map_memory2)
 	vkMapMemory2KHR = (PFN_vkMapMemory2KHR)load(context, "vkMapMemory2KHR");
 	vkUnmapMemory2KHR = (PFN_vkUnmapMemory2KHR)load(context, "vkUnmapMemory2KHR");
@@ -1141,26 +1192,44 @@ static void volkGenLoadDevice(void* context, PFN_vkVoidFunction (*load)(void*, c
 #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
 	vkCmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT)load(context, "vkCmdSetAlphaToCoverageEnableEXT");
 	vkCmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)load(context, "vkCmdSetAlphaToOneEnableEXT");
-	vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
 	vkCmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)load(context, "vkCmdSetColorBlendEnableEXT");
 	vkCmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)load(context, "vkCmdSetColorBlendEquationEXT");
 	vkCmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)load(context, "vkCmdSetColorWriteMaskEXT");
-	vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
 	vkCmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)load(context, "vkCmdSetDepthClampEnableEXT");
-	vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
-	vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
-	vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
-	vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
-	vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
 	vkCmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)load(context, "vkCmdSetLogicOpEnableEXT");
 	vkCmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)load(context, "vkCmdSetPolygonModeEXT");
-	vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
 	vkCmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)load(context, "vkCmdSetRasterizationSamplesEXT");
-	vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
-	vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
 	vkCmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)load(context, "vkCmdSetSampleMaskEXT");
-	vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
 #endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
+	vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
+	vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
+	vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
+	vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
+	vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
+	vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
+	vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
+	vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
+	vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
+	vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
+	vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
 #if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
 	vkCmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV)load(context, "vkCmdSetViewportWScalingEnableNV");
 #endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
@@ -1649,6 +1718,9 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
 	table->vkGetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)load(context, "vkGetBufferOpaqueCaptureAddressKHR");
 	table->vkGetDeviceMemoryOpaqueCaptureAddressKHR = (PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)load(context, "vkGetDeviceMemoryOpaqueCaptureAddressKHR");
 #endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_calibrated_timestamps)
+	table->vkGetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)load(context, "vkGetCalibratedTimestampsKHR");
+#endif /* defined(VK_KHR_calibrated_timestamps) */
 #if defined(VK_KHR_copy_commands2)
 	table->vkCmdBlitImage2KHR = (PFN_vkCmdBlitImage2KHR)load(context, "vkCmdBlitImage2KHR");
 	table->vkCmdCopyBuffer2KHR = (PFN_vkCmdCopyBuffer2KHR)load(context, "vkCmdCopyBuffer2KHR");
@@ -1691,6 +1763,10 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
 	table->vkCmdBeginRenderingKHR = (PFN_vkCmdBeginRenderingKHR)load(context, "vkCmdBeginRenderingKHR");
 	table->vkCmdEndRenderingKHR = (PFN_vkCmdEndRenderingKHR)load(context, "vkCmdEndRenderingKHR");
 #endif /* defined(VK_KHR_dynamic_rendering) */
+#if defined(VK_KHR_dynamic_rendering_local_read)
+	table->vkCmdSetRenderingAttachmentLocationsKHR = (PFN_vkCmdSetRenderingAttachmentLocationsKHR)load(context, "vkCmdSetRenderingAttachmentLocationsKHR");
+	table->vkCmdSetRenderingInputAttachmentIndicesKHR = (PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)load(context, "vkCmdSetRenderingInputAttachmentIndicesKHR");
+#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
 #if defined(VK_KHR_external_fence_fd)
 	table->vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)load(context, "vkGetFenceFdKHR");
 	table->vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)load(context, "vkImportFenceFdKHR");
@@ -1723,6 +1799,9 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
 	table->vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)load(context, "vkGetImageMemoryRequirements2KHR");
 	table->vkGetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)load(context, "vkGetImageSparseMemoryRequirements2KHR");
 #endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_line_rasterization)
+	table->vkCmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)load(context, "vkCmdSetLineStippleKHR");
+#endif /* defined(VK_KHR_line_rasterization) */
 #if defined(VK_KHR_maintenance1)
 	table->vkTrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)load(context, "vkTrimCommandPoolKHR");
 #endif /* defined(VK_KHR_maintenance1) */
@@ -1740,6 +1819,18 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
 	table->vkGetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)load(context, "vkGetImageSubresourceLayout2KHR");
 	table->vkGetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)load(context, "vkGetRenderingAreaGranularityKHR");
 #endif /* defined(VK_KHR_maintenance5) */
+#if defined(VK_KHR_maintenance6)
+	table->vkCmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)load(context, "vkCmdBindDescriptorSets2KHR");
+	table->vkCmdPushConstants2KHR = (PFN_vkCmdPushConstants2KHR)load(context, "vkCmdPushConstants2KHR");
+#endif /* defined(VK_KHR_maintenance6) */
+#if defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor)
+	table->vkCmdPushDescriptorSet2KHR = (PFN_vkCmdPushDescriptorSet2KHR)load(context, "vkCmdPushDescriptorSet2KHR");
+	table->vkCmdPushDescriptorSetWithTemplate2KHR = (PFN_vkCmdPushDescriptorSetWithTemplate2KHR)load(context, "vkCmdPushDescriptorSetWithTemplate2KHR");
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer)
+	table->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = (PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)load(context, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT");
+	table->vkCmdSetDescriptorBufferOffsets2EXT = (PFN_vkCmdSetDescriptorBufferOffsets2EXT)load(context, "vkCmdSetDescriptorBufferOffsets2EXT");
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer) */
 #if defined(VK_KHR_map_memory2)
 	table->vkMapMemory2KHR = (PFN_vkMapMemory2KHR)load(context, "vkMapMemory2KHR");
 	table->vkUnmapMemory2KHR = (PFN_vkUnmapMemory2KHR)load(context, "vkUnmapMemory2KHR");
@@ -1957,26 +2048,44 @@ static void volkGenLoadDeviceTable(struct VolkDeviceTable* table, void* context,
 #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
 	table->vkCmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT)load(context, "vkCmdSetAlphaToCoverageEnableEXT");
 	table->vkCmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)load(context, "vkCmdSetAlphaToOneEnableEXT");
-	table->vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
 	table->vkCmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)load(context, "vkCmdSetColorBlendEnableEXT");
 	table->vkCmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)load(context, "vkCmdSetColorBlendEquationEXT");
 	table->vkCmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)load(context, "vkCmdSetColorWriteMaskEXT");
-	table->vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
 	table->vkCmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)load(context, "vkCmdSetDepthClampEnableEXT");
-	table->vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
-	table->vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
-	table->vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
-	table->vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
-	table->vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
 	table->vkCmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)load(context, "vkCmdSetLogicOpEnableEXT");
 	table->vkCmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)load(context, "vkCmdSetPolygonModeEXT");
-	table->vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
 	table->vkCmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)load(context, "vkCmdSetRasterizationSamplesEXT");
-	table->vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
-	table->vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
 	table->vkCmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)load(context, "vkCmdSetSampleMaskEXT");
-	table->vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
 #endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
+	table->vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)load(context, "vkCmdSetTessellationDomainOriginEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
+	table->vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)load(context, "vkCmdSetRasterizationStreamEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
+	table->vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)load(context, "vkCmdSetConservativeRasterizationModeEXT");
+	table->vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)load(context, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
+	table->vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)load(context, "vkCmdSetDepthClipEnableEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
+	table->vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)load(context, "vkCmdSetSampleLocationsEnableEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
+	table->vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)load(context, "vkCmdSetColorBlendAdvancedEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
+	table->vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)load(context, "vkCmdSetProvokingVertexModeEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
+	table->vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)load(context, "vkCmdSetLineRasterizationModeEXT");
+	table->vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)load(context, "vkCmdSetLineStippleEnableEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
+	table->vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)load(context, "vkCmdSetDepthClipNegativeOneToOneEXT");
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
 #if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
 	table->vkCmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV)load(context, "vkCmdSetViewportWScalingEnableNV");
 #endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
@@ -2558,6 +2667,10 @@ PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR;
 PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR;
 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR;
 #endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_calibrated_timestamps)
+PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR;
+PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR;
+#endif /* defined(VK_KHR_calibrated_timestamps) */
 #if defined(VK_KHR_cooperative_matrix)
 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR;
 #endif /* defined(VK_KHR_cooperative_matrix) */
@@ -2615,6 +2728,10 @@ PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR;
 PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
 PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
 #endif /* defined(VK_KHR_dynamic_rendering) */
+#if defined(VK_KHR_dynamic_rendering_local_read)
+PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR;
+PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR;
+#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
 #if defined(VK_KHR_external_fence_capabilities)
 PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR;
 #endif /* defined(VK_KHR_external_fence_capabilities) */
@@ -2676,6 +2793,9 @@ PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparse
 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
 #endif /* defined(VK_KHR_get_surface_capabilities2) */
+#if defined(VK_KHR_line_rasterization)
+PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR;
+#endif /* defined(VK_KHR_line_rasterization) */
 #if defined(VK_KHR_maintenance1)
 PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
 #endif /* defined(VK_KHR_maintenance1) */
@@ -2693,6 +2813,18 @@ PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR;
 PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR;
 PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR;
 #endif /* defined(VK_KHR_maintenance5) */
+#if defined(VK_KHR_maintenance6)
+PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR;
+PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR;
+#endif /* defined(VK_KHR_maintenance6) */
+#if defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor)
+PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR;
+PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR;
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer)
+PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT;
+PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT;
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer) */
 #if defined(VK_KHR_map_memory2)
 PFN_vkMapMemory2KHR vkMapMemory2KHR;
 PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR;
@@ -2965,26 +3097,44 @@ PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT;
 #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
 PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
 PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
-PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
 PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
 PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
 PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
-PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
 PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
-PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
-PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
-PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
-PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
-PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
 PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
 PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
-PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
 PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
-PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
-PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
 PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
-PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
 #endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
+PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
+PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
+PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
+PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
+PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
+PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
+PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
+PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
+PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
+PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
+PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
 #if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
 PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
 #endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
diff --git a/WickedEngine/Utility/volk.h b/WickedEngine/Utility/volk.h
index 315a595af..524717e0c 100644
--- a/WickedEngine/Utility/volk.h
+++ b/WickedEngine/Utility/volk.h
@@ -1,7 +1,7 @@
 /**
  * volk
  *
- * Copyright (C) 2018-2023, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Copyright (C) 2018-2024, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
  * Report bugs and download new versions at https://github.com/zeux/volk
  *
  * This library is distributed under the MIT License. See notice at the end of this file.
@@ -15,7 +15,7 @@
 #endif
 
 /* VOLK_GENERATE_VERSION_DEFINE */
-#define VOLK_HEADER_VERSION 272
+#define VOLK_HEADER_VERSION 290
 /* VOLK_GENERATE_VERSION_DEFINE */
 
 #ifndef VK_NO_PROTOTYPES
@@ -577,6 +577,9 @@ struct VolkDeviceTable
 	PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR;
 	PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR;
 #endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_calibrated_timestamps)
+	PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR;
+#endif /* defined(VK_KHR_calibrated_timestamps) */
 #if defined(VK_KHR_copy_commands2)
 	PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR;
 	PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR;
@@ -619,6 +622,10 @@ struct VolkDeviceTable
 	PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
 	PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
 #endif /* defined(VK_KHR_dynamic_rendering) */
+#if defined(VK_KHR_dynamic_rendering_local_read)
+	PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR;
+	PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR;
+#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
 #if defined(VK_KHR_external_fence_fd)
 	PFN_vkGetFenceFdKHR vkGetFenceFdKHR;
 	PFN_vkImportFenceFdKHR vkImportFenceFdKHR;
@@ -651,6 +658,9 @@ struct VolkDeviceTable
 	PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
 	PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR;
 #endif /* defined(VK_KHR_get_memory_requirements2) */
+#if defined(VK_KHR_line_rasterization)
+	PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR;
+#endif /* defined(VK_KHR_line_rasterization) */
 #if defined(VK_KHR_maintenance1)
 	PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
 #endif /* defined(VK_KHR_maintenance1) */
@@ -668,6 +678,18 @@ struct VolkDeviceTable
 	PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR;
 	PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR;
 #endif /* defined(VK_KHR_maintenance5) */
+#if defined(VK_KHR_maintenance6)
+	PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR;
+	PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR;
+#endif /* defined(VK_KHR_maintenance6) */
+#if defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor)
+	PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR;
+	PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR;
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer)
+	PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT;
+	PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT;
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer) */
 #if defined(VK_KHR_map_memory2)
 	PFN_vkMapMemory2KHR vkMapMemory2KHR;
 	PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR;
@@ -885,26 +907,44 @@ struct VolkDeviceTable
 #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
 	PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
 	PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
-	PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
 	PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
 	PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
 	PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
-	PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
 	PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
-	PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
-	PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
-	PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
-	PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
-	PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
 	PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
 	PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
-	PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
 	PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
-	PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
-	PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
 	PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
-	PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
 #endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
+	PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
+	PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
+	PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
+	PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
+	PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
+	PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
+	PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
+	PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
+	PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
+	PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
+	PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
 #if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
 	PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
 #endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
@@ -1478,6 +1518,10 @@ extern PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR;
 extern PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR;
 extern PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR;
 #endif /* defined(VK_KHR_buffer_device_address) */
+#if defined(VK_KHR_calibrated_timestamps)
+extern PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR;
+extern PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR;
+#endif /* defined(VK_KHR_calibrated_timestamps) */
 #if defined(VK_KHR_cooperative_matrix)
 extern PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR;
 #endif /* defined(VK_KHR_cooperative_matrix) */
@@ -1535,6 +1579,10 @@ extern PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR;
 extern PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
 extern PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
 #endif /* defined(VK_KHR_dynamic_rendering) */
+#if defined(VK_KHR_dynamic_rendering_local_read)
+extern PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR;
+extern PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR;
+#endif /* defined(VK_KHR_dynamic_rendering_local_read) */
 #if defined(VK_KHR_external_fence_capabilities)
 extern PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR;
 #endif /* defined(VK_KHR_external_fence_capabilities) */
@@ -1596,6 +1644,9 @@ extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDevic
 extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
 extern PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
 #endif /* defined(VK_KHR_get_surface_capabilities2) */
+#if defined(VK_KHR_line_rasterization)
+extern PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR;
+#endif /* defined(VK_KHR_line_rasterization) */
 #if defined(VK_KHR_maintenance1)
 extern PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR;
 #endif /* defined(VK_KHR_maintenance1) */
@@ -1613,6 +1664,18 @@ extern PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayou
 extern PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR;
 extern PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR;
 #endif /* defined(VK_KHR_maintenance5) */
+#if defined(VK_KHR_maintenance6)
+extern PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR;
+extern PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR;
+#endif /* defined(VK_KHR_maintenance6) */
+#if defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor)
+extern PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR;
+extern PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR;
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_KHR_push_descriptor) */
+#if defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer)
+extern PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT;
+extern PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT;
+#endif /* defined(VK_KHR_maintenance6) && defined(VK_EXT_descriptor_buffer) */
 #if defined(VK_KHR_map_memory2)
 extern PFN_vkMapMemory2KHR vkMapMemory2KHR;
 extern PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR;
@@ -1885,26 +1948,44 @@ extern PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT
 #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object))
 extern PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
 extern PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
-extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
 extern PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
 extern PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
 extern PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
-extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
 extern PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
-extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
-extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
-extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
-extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
-extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
 extern PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
 extern PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
-extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
 extern PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
-extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
-extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
 extern PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
-extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
 #endif /* (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object))
+extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && (defined(VK_KHR_maintenance2) || defined(VK_VERSION_1_1))) || (defined(VK_EXT_shader_object)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback))
+extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_transform_feedback)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_transform_feedback)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization))
+extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
+extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_conservative_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_conservative_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable))
+extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_enable)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_enable)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations))
+extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_sample_locations)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_sample_locations)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced))
+extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_blend_operation_advanced)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_blend_operation_advanced)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex))
+extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_provoking_vertex)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_provoking_vertex)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization))
+extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
+extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_line_rasterization)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_line_rasterization)) */
+#if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control))
+extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
+#endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_EXT_depth_clip_control)) || (defined(VK_EXT_shader_object) && defined(VK_EXT_depth_clip_control)) */
 #if (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling))
 extern PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
 #endif /* (defined(VK_EXT_extended_dynamic_state3) && defined(VK_NV_clip_space_w_scaling)) || (defined(VK_EXT_shader_object) && defined(VK_NV_clip_space_w_scaling)) */
@@ -1965,7 +2046,7 @@ extern PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR;
 #endif
 
 /**
- * Copyright (c) 2018-2023 Arseny Kapoulkine
+ * Copyright (c) 2018-2024 Arseny Kapoulkine
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/WickedEngine/Utility/vulkan/vk_platform.h b/WickedEngine/Utility/vulkan/vk_platform.h
index ed67a6004..0ecd4f647 100644
--- a/WickedEngine/Utility/vulkan/vk_platform.h
+++ b/WickedEngine/Utility/vulkan/vk_platform.h
@@ -2,7 +2,7 @@
 // File: vk_platform.h
 //
 /*
-** Copyright 2014-2023 The Khronos Group Inc.
+** Copyright 2014-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vk_sdk_platform.h b/WickedEngine/Utility/vulkan/vk_sdk_platform.h
deleted file mode 100644
index 3bdf5057b..000000000
--- a/WickedEngine/Utility/vulkan/vk_sdk_platform.h
+++ /dev/null
@@ -1,81 +0,0 @@
-//
-// File: vk_sdk_platform.h
-//
-/*
- * Copyright (c) 2015-2023 LunarG, Inc.
- * Copyright (c) 2015-2023 The Khronos Group Inc.
- * Copyright (c) 2015-2023 Valve Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-// Allow users to suppress warnings generated by this header file by defining VK_SDK_PLATFORM_SUPRRESS_DEPRECATION_WARNING
-#ifndef VK_SDK_PLATFORM_SUPRRESS_DEPRECATION_WARNING
-
-#if defined(__GNUC__) && __GNUC__ >= 4
-#warning "vk_sdk_platform.h is deprecated and will be removed in future release! Use VK_SDK_PLATFORM_SUPRRESS_DEPRECATION_WARNING to suppress warning!"
-#endif
-
-// MSVC doesn't support warning directive
-#if defined(_MSC_VER)
-#pragma message("vk_sdk_platform.h is deprecated and will be removed in future release! Use VK_SDK_PLATFORM_SUPRRESS_DEPRECATION_WARNING to suppress warning!")
-#endif
-
-#endif
-
-#if defined(_WIN32)
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#ifndef __cplusplus
-#undef inline
-#define inline __inline
-#endif // __cplusplus
-
-#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/)
-// C99:
-// Microsoft didn't implement C99 in Visual Studio; but started adding it with
-// VS2013.  However, VS2013 still didn't have snprintf().  The following is a
-// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the
-// "CMakeLists.txt" file).
-// NOTE: This is fixed in Visual Studio 2015.
-#define snprintf _snprintf
-#endif
-
-#define strdup _strdup
-
-#endif // _WIN32
-
-// Check for noexcept support using clang, with fallback to Windows or GCC version numbers
-#ifndef NOEXCEPT
-#if defined(__clang__)
-#if __has_feature(cxx_noexcept)
-#define HAS_NOEXCEPT
-#endif
-#else
-#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46
-#define HAS_NOEXCEPT
-#else
-#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
-#define HAS_NOEXCEPT
-#endif
-#endif
-#endif
-
-#ifdef HAS_NOEXCEPT
-#define NOEXCEPT noexcept
-#else
-#define NOEXCEPT
-#endif
-#endif
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_av1std.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_av1std.h
new file mode 100644
index 000000000..8ce283e8a
--- /dev/null
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_av1std.h
@@ -0,0 +1,392 @@
+#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_
+#define VULKAN_VIDEO_CODEC_AV1STD_H_ 1
+
+/*
+** Copyright 2015-2024 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_av1std 1
+#include "vulkan_video_codecs_common.h"
+#define STD_VIDEO_AV1_NUM_REF_FRAMES      8
+#define STD_VIDEO_AV1_REFS_PER_FRAME      7
+#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8
+#define STD_VIDEO_AV1_MAX_TILE_COLS       64
+#define STD_VIDEO_AV1_MAX_TILE_ROWS       64
+#define STD_VIDEO_AV1_MAX_SEGMENTS        8
+#define STD_VIDEO_AV1_SEG_LVL_MAX         8
+#define STD_VIDEO_AV1_PRIMARY_REF_NONE    7
+#define STD_VIDEO_AV1_SELECT_INTEGER_MV   2
+#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2
+#define STD_VIDEO_AV1_SKIP_MODE_FRAMES    2
+#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4
+#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2
+#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8
+#define STD_VIDEO_AV1_MAX_NUM_PLANES      3
+#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6
+#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS    14
+#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS   10
+#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS   10
+#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA    24
+#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA  25
+
+typedef enum StdVideoAV1Profile {
+    STD_VIDEO_AV1_PROFILE_MAIN = 0,
+    STD_VIDEO_AV1_PROFILE_HIGH = 1,
+    STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2,
+    STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1Profile;
+
+typedef enum StdVideoAV1Level {
+    STD_VIDEO_AV1_LEVEL_2_0 = 0,
+    STD_VIDEO_AV1_LEVEL_2_1 = 1,
+    STD_VIDEO_AV1_LEVEL_2_2 = 2,
+    STD_VIDEO_AV1_LEVEL_2_3 = 3,
+    STD_VIDEO_AV1_LEVEL_3_0 = 4,
+    STD_VIDEO_AV1_LEVEL_3_1 = 5,
+    STD_VIDEO_AV1_LEVEL_3_2 = 6,
+    STD_VIDEO_AV1_LEVEL_3_3 = 7,
+    STD_VIDEO_AV1_LEVEL_4_0 = 8,
+    STD_VIDEO_AV1_LEVEL_4_1 = 9,
+    STD_VIDEO_AV1_LEVEL_4_2 = 10,
+    STD_VIDEO_AV1_LEVEL_4_3 = 11,
+    STD_VIDEO_AV1_LEVEL_5_0 = 12,
+    STD_VIDEO_AV1_LEVEL_5_1 = 13,
+    STD_VIDEO_AV1_LEVEL_5_2 = 14,
+    STD_VIDEO_AV1_LEVEL_5_3 = 15,
+    STD_VIDEO_AV1_LEVEL_6_0 = 16,
+    STD_VIDEO_AV1_LEVEL_6_1 = 17,
+    STD_VIDEO_AV1_LEVEL_6_2 = 18,
+    STD_VIDEO_AV1_LEVEL_6_3 = 19,
+    STD_VIDEO_AV1_LEVEL_7_0 = 20,
+    STD_VIDEO_AV1_LEVEL_7_1 = 21,
+    STD_VIDEO_AV1_LEVEL_7_2 = 22,
+    STD_VIDEO_AV1_LEVEL_7_3 = 23,
+    STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1Level;
+
+typedef enum StdVideoAV1FrameType {
+    STD_VIDEO_AV1_FRAME_TYPE_KEY = 0,
+    STD_VIDEO_AV1_FRAME_TYPE_INTER = 1,
+    STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2,
+    STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3,
+    STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1FrameType;
+
+typedef enum StdVideoAV1ReferenceName {
+    STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0,
+    STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1,
+    STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2,
+    STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3,
+    STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4,
+    STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5,
+    STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6,
+    STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7,
+    STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1ReferenceName;
+
+typedef enum StdVideoAV1InterpolationFilter {
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1InterpolationFilter;
+
+typedef enum StdVideoAV1TxMode {
+    STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0,
+    STD_VIDEO_AV1_TX_MODE_LARGEST = 1,
+    STD_VIDEO_AV1_TX_MODE_SELECT = 2,
+    STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1TxMode;
+
+typedef enum StdVideoAV1FrameRestorationType {
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1FrameRestorationType;
+
+typedef enum StdVideoAV1ColorPrimaries {
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = 2,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1ColorPrimaries;
+
+typedef enum StdVideoAV1TransferCharacteristics {
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1TransferCharacteristics;
+
+typedef enum StdVideoAV1MatrixCoefficients {
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1MatrixCoefficients;
+
+typedef enum StdVideoAV1ChromaSamplePosition {
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1ChromaSamplePosition;
+typedef struct StdVideoAV1ColorConfigFlags {
+    uint32_t    mono_chrome : 1;
+    uint32_t    color_range : 1;
+    uint32_t    separate_uv_delta_q : 1;
+    uint32_t    color_description_present_flag : 1;
+    uint32_t    reserved : 28;
+} StdVideoAV1ColorConfigFlags;
+
+typedef struct StdVideoAV1ColorConfig {
+    StdVideoAV1ColorConfigFlags           flags;
+    uint8_t                               BitDepth;
+    uint8_t                               subsampling_x;
+    uint8_t                               subsampling_y;
+    uint8_t                               reserved1;
+    StdVideoAV1ColorPrimaries             color_primaries;
+    StdVideoAV1TransferCharacteristics    transfer_characteristics;
+    StdVideoAV1MatrixCoefficients         matrix_coefficients;
+    StdVideoAV1ChromaSamplePosition       chroma_sample_position;
+} StdVideoAV1ColorConfig;
+
+typedef struct StdVideoAV1TimingInfoFlags {
+    uint32_t    equal_picture_interval : 1;
+    uint32_t    reserved : 31;
+} StdVideoAV1TimingInfoFlags;
+
+typedef struct StdVideoAV1TimingInfo {
+    StdVideoAV1TimingInfoFlags    flags;
+    uint32_t                      num_units_in_display_tick;
+    uint32_t                      time_scale;
+    uint32_t                      num_ticks_per_picture_minus_1;
+} StdVideoAV1TimingInfo;
+
+typedef struct StdVideoAV1LoopFilterFlags {
+    uint32_t    loop_filter_delta_enabled : 1;
+    uint32_t    loop_filter_delta_update : 1;
+    uint32_t    reserved : 30;
+} StdVideoAV1LoopFilterFlags;
+
+typedef struct StdVideoAV1LoopFilter {
+    StdVideoAV1LoopFilterFlags    flags;
+    uint8_t                       loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS];
+    uint8_t                       loop_filter_sharpness;
+    uint8_t                       update_ref_delta;
+    int8_t                        loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME];
+    uint8_t                       update_mode_delta;
+    int8_t                        loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS];
+} StdVideoAV1LoopFilter;
+
+typedef struct StdVideoAV1QuantizationFlags {
+    uint32_t    using_qmatrix : 1;
+    uint32_t    diff_uv_delta : 1;
+    uint32_t    reserved : 30;
+} StdVideoAV1QuantizationFlags;
+
+typedef struct StdVideoAV1Quantization {
+    StdVideoAV1QuantizationFlags    flags;
+    uint8_t                         base_q_idx;
+    int8_t                          DeltaQYDc;
+    int8_t                          DeltaQUDc;
+    int8_t                          DeltaQUAc;
+    int8_t                          DeltaQVDc;
+    int8_t                          DeltaQVAc;
+    uint8_t                         qm_y;
+    uint8_t                         qm_u;
+    uint8_t                         qm_v;
+} StdVideoAV1Quantization;
+
+typedef struct StdVideoAV1Segmentation {
+    uint8_t    FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS];
+    int16_t    FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX];
+} StdVideoAV1Segmentation;
+
+typedef struct StdVideoAV1TileInfoFlags {
+    uint32_t    uniform_tile_spacing_flag : 1;
+    uint32_t    reserved : 31;
+} StdVideoAV1TileInfoFlags;
+
+typedef struct StdVideoAV1TileInfo {
+    StdVideoAV1TileInfoFlags    flags;
+    uint8_t                     TileCols;
+    uint8_t                     TileRows;
+    uint16_t                    context_update_tile_id;
+    uint8_t                     tile_size_bytes_minus_1;
+    uint8_t                     reserved1[7];
+    const uint16_t*             pMiColStarts;
+    const uint16_t*             pMiRowStarts;
+    const uint16_t*             pWidthInSbsMinus1;
+    const uint16_t*             pHeightInSbsMinus1;
+} StdVideoAV1TileInfo;
+
+typedef struct StdVideoAV1CDEF {
+    uint8_t    cdef_damping_minus_3;
+    uint8_t    cdef_bits;
+    uint8_t    cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+    uint8_t    cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+    uint8_t    cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+    uint8_t    cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+} StdVideoAV1CDEF;
+
+typedef struct StdVideoAV1LoopRestoration {
+    StdVideoAV1FrameRestorationType    FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES];
+    uint16_t                           LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES];
+} StdVideoAV1LoopRestoration;
+
+typedef struct StdVideoAV1GlobalMotion {
+    uint8_t    GmType[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    int32_t    gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS];
+} StdVideoAV1GlobalMotion;
+
+typedef struct StdVideoAV1FilmGrainFlags {
+    uint32_t    chroma_scaling_from_luma : 1;
+    uint32_t    overlap_flag : 1;
+    uint32_t    clip_to_restricted_range : 1;
+    uint32_t    update_grain : 1;
+    uint32_t    reserved : 28;
+} StdVideoAV1FilmGrainFlags;
+
+typedef struct StdVideoAV1FilmGrain {
+    StdVideoAV1FilmGrainFlags    flags;
+    uint8_t                      grain_scaling_minus_8;
+    uint8_t                      ar_coeff_lag;
+    uint8_t                      ar_coeff_shift_minus_6;
+    uint8_t                      grain_scale_shift;
+    uint16_t                     grain_seed;
+    uint8_t                      film_grain_params_ref_idx;
+    uint8_t                      num_y_points;
+    uint8_t                      point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
+    uint8_t                      point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
+    uint8_t                      num_cb_points;
+    uint8_t                      point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
+    uint8_t                      point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
+    uint8_t                      num_cr_points;
+    uint8_t                      point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
+    uint8_t                      point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
+    int8_t                       ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA];
+    int8_t                       ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
+    int8_t                       ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
+    uint8_t                      cb_mult;
+    uint8_t                      cb_luma_mult;
+    uint16_t                     cb_offset;
+    uint8_t                      cr_mult;
+    uint8_t                      cr_luma_mult;
+    uint16_t                     cr_offset;
+} StdVideoAV1FilmGrain;
+
+typedef struct StdVideoAV1SequenceHeaderFlags {
+    uint32_t    still_picture : 1;
+    uint32_t    reduced_still_picture_header : 1;
+    uint32_t    use_128x128_superblock : 1;
+    uint32_t    enable_filter_intra : 1;
+    uint32_t    enable_intra_edge_filter : 1;
+    uint32_t    enable_interintra_compound : 1;
+    uint32_t    enable_masked_compound : 1;
+    uint32_t    enable_warped_motion : 1;
+    uint32_t    enable_dual_filter : 1;
+    uint32_t    enable_order_hint : 1;
+    uint32_t    enable_jnt_comp : 1;
+    uint32_t    enable_ref_frame_mvs : 1;
+    uint32_t    frame_id_numbers_present_flag : 1;
+    uint32_t    enable_superres : 1;
+    uint32_t    enable_cdef : 1;
+    uint32_t    enable_restoration : 1;
+    uint32_t    film_grain_params_present : 1;
+    uint32_t    timing_info_present_flag : 1;
+    uint32_t    initial_display_delay_present_flag : 1;
+    uint32_t    reserved : 13;
+} StdVideoAV1SequenceHeaderFlags;
+
+typedef struct StdVideoAV1SequenceHeader {
+    StdVideoAV1SequenceHeaderFlags    flags;
+    StdVideoAV1Profile                seq_profile;
+    uint8_t                           frame_width_bits_minus_1;
+    uint8_t                           frame_height_bits_minus_1;
+    uint16_t                          max_frame_width_minus_1;
+    uint16_t                          max_frame_height_minus_1;
+    uint8_t                           delta_frame_id_length_minus_2;
+    uint8_t                           additional_frame_id_length_minus_1;
+    uint8_t                           order_hint_bits_minus_1;
+    uint8_t                           seq_force_integer_mv;
+    uint8_t                           seq_force_screen_content_tools;
+    uint8_t                           reserved1[5];
+    const StdVideoAV1ColorConfig*     pColorConfig;
+    const StdVideoAV1TimingInfo*      pTimingInfo;
+} StdVideoAV1SequenceHeader;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_av1std_decode.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_av1std_decode.h
new file mode 100644
index 000000000..6b8130cd9
--- /dev/null
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_av1std_decode.h
@@ -0,0 +1,109 @@
+#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_
+#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1
+
+/*
+** Copyright 2015-2024 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_av1std_decode 1
+#include "vulkan_video_codec_av1std.h"
+
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode"
+typedef struct StdVideoDecodeAV1PictureInfoFlags {
+    uint32_t    error_resilient_mode : 1;
+    uint32_t    disable_cdf_update : 1;
+    uint32_t    use_superres : 1;
+    uint32_t    render_and_frame_size_different : 1;
+    uint32_t    allow_screen_content_tools : 1;
+    uint32_t    is_filter_switchable : 1;
+    uint32_t    force_integer_mv : 1;
+    uint32_t    frame_size_override_flag : 1;
+    uint32_t    buffer_removal_time_present_flag : 1;
+    uint32_t    allow_intrabc : 1;
+    uint32_t    frame_refs_short_signaling : 1;
+    uint32_t    allow_high_precision_mv : 1;
+    uint32_t    is_motion_mode_switchable : 1;
+    uint32_t    use_ref_frame_mvs : 1;
+    uint32_t    disable_frame_end_update_cdf : 1;
+    uint32_t    allow_warped_motion : 1;
+    uint32_t    reduced_tx_set : 1;
+    uint32_t    reference_select : 1;
+    uint32_t    skip_mode_present : 1;
+    uint32_t    delta_q_present : 1;
+    uint32_t    delta_lf_present : 1;
+    uint32_t    delta_lf_multi : 1;
+    uint32_t    segmentation_enabled : 1;
+    uint32_t    segmentation_update_map : 1;
+    uint32_t    segmentation_temporal_update : 1;
+    uint32_t    segmentation_update_data : 1;
+    uint32_t    UsesLr : 1;
+    uint32_t    usesChromaLr : 1;
+    uint32_t    apply_grain : 1;
+    uint32_t    reserved : 3;
+} StdVideoDecodeAV1PictureInfoFlags;
+
+typedef struct StdVideoDecodeAV1PictureInfo {
+    StdVideoDecodeAV1PictureInfoFlags    flags;
+    StdVideoAV1FrameType                 frame_type;
+    uint32_t                             current_frame_id;
+    uint8_t                              OrderHint;
+    uint8_t                              primary_ref_frame;
+    uint8_t                              refresh_frame_flags;
+    uint8_t                              reserved1;
+    StdVideoAV1InterpolationFilter       interpolation_filter;
+    StdVideoAV1TxMode                    TxMode;
+    uint8_t                              delta_q_res;
+    uint8_t                              delta_lf_res;
+    uint8_t                              SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES];
+    uint8_t                              coded_denom;
+    uint8_t                              reserved2[3];
+    uint8_t                              OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    uint32_t                             expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    const StdVideoAV1TileInfo*           pTileInfo;
+    const StdVideoAV1Quantization*       pQuantization;
+    const StdVideoAV1Segmentation*       pSegmentation;
+    const StdVideoAV1LoopFilter*         pLoopFilter;
+    const StdVideoAV1CDEF*               pCDEF;
+    const StdVideoAV1LoopRestoration*    pLoopRestoration;
+    const StdVideoAV1GlobalMotion*       pGlobalMotion;
+    const StdVideoAV1FilmGrain*          pFilmGrain;
+} StdVideoDecodeAV1PictureInfo;
+
+typedef struct StdVideoDecodeAV1ReferenceInfoFlags {
+    uint32_t    disable_frame_end_update_cdf : 1;
+    uint32_t    segmentation_enabled : 1;
+    uint32_t    reserved : 30;
+} StdVideoDecodeAV1ReferenceInfoFlags;
+
+typedef struct StdVideoDecodeAV1ReferenceInfo {
+    StdVideoDecodeAV1ReferenceInfoFlags    flags;
+    uint8_t                                frame_type;
+    uint8_t                                RefFrameSignBias;
+    uint8_t                                OrderHint;
+    uint8_t                                SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
+} StdVideoDecodeAV1ReferenceInfo;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std.h
index ef7eaf745..6d27af37b 100644
--- a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std.h
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std.h
@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_decode.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_decode.h
index dd24112e2..439cb885e 100644
--- a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_decode.h
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_decode.h
@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_encode.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_encode.h
index 58b8bdb2f..9e24aa5d9 100644
--- a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_encode.h
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h264std_encode.h
@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -22,10 +22,10 @@ extern "C" {
 // vulkan_video_codec_h264std_encode is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h264std_encode 1
 #include "vulkan_video_codec_h264std.h"
-// Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number
-#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_11 VK_MAKE_VIDEO_STD_VERSION(0, 9, 11)
 
-#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_11
+#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode"
 typedef struct StdVideoEncodeH264WeightTableFlags {
     uint32_t    luma_weight_l0_flag;
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std.h
index ff5d0dacb..d0a1bacbe 100644
--- a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std.h
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std.h
@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_decode.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_decode.h
index 75cf4d094..0178793e5 100644
--- a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_decode.h
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_decode.h
@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_encode.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_encode.h
index 2a7024cab..ee34491f4 100644
--- a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_encode.h
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codec_h265std_encode.h
@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -22,10 +22,10 @@ extern "C" {
 // vulkan_video_codec_h265std_encode is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h265std_encode 1
 #include "vulkan_video_codec_h265std.h"
-// Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number
-#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_12 VK_MAKE_VIDEO_STD_VERSION(0, 9, 12)
 
-#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_12
+#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode"
 typedef struct StdVideoEncodeH265WeightTableFlags {
     uint16_t    luma_weight_l0_flag;
diff --git a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codecs_common.h b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codecs_common.h
index 6568975ee..5e6ef1db4 100644
--- a/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codecs_common.h
+++ b/WickedEngine/Utility/vulkan/vk_video/vulkan_video_codecs_common.h
@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODECS_COMMON_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan.h b/WickedEngine/Utility/vulkan/vulkan.h
index 426cff58d..ef94006bb 100644
--- a/WickedEngine/Utility/vulkan/vulkan.h
+++ b/WickedEngine/Utility/vulkan/vulkan.h
@@ -2,7 +2,7 @@
 #define VULKAN_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_android.h b/WickedEngine/Utility/vulkan/vulkan_android.h
index 40b3c67ba..61ff40ba8 100644
--- a/WickedEngine/Utility/vulkan/vulkan_android.h
+++ b/WickedEngine/Utility/vulkan/vulkan_android.h
@@ -2,7 +2,7 @@
 #define VULKAN_ANDROID_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_beta.h b/WickedEngine/Utility/vulkan/vulkan_beta.h
index 1871651d2..df18b4042 100644
--- a/WickedEngine/Utility/vulkan/vulkan_beta.h
+++ b/WickedEngine/Utility/vulkan/vulkan_beta.h
@@ -2,7 +2,7 @@
 #define VULKAN_BETA_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -51,603 +51,6 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
 
 
 
-// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls.
-#define VK_KHR_video_encode_queue 1
-#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 10
-#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
-
-typedef enum VkVideoEncodeTuningModeKHR {
-    VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1,
-    VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2,
-    VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3,
-    VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4,
-    VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeTuningModeKHR;
-typedef VkFlags VkVideoEncodeFlagsKHR;
-
-typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
-    VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeCapabilityFlagBitsKHR;
-typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
-
-typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeRateControlModeFlagBitsKHR;
-typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
-
-typedef enum VkVideoEncodeFeedbackFlagBitsKHR {
-    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeFeedbackFlagBitsKHR;
-typedef VkFlags VkVideoEncodeFeedbackFlagsKHR;
-
-typedef enum VkVideoEncodeUsageFlagBitsKHR {
-    VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008,
-    VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeUsageFlagBitsKHR;
-typedef VkFlags VkVideoEncodeUsageFlagsKHR;
-
-typedef enum VkVideoEncodeContentFlagBitsKHR {
-    VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeContentFlagBitsKHR;
-typedef VkFlags VkVideoEncodeContentFlagsKHR;
-typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
-typedef struct VkVideoEncodeInfoKHR {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkVideoEncodeFlagsKHR                 flags;
-    VkBuffer                              dstBuffer;
-    VkDeviceSize                          dstBufferOffset;
-    VkDeviceSize                          dstBufferRange;
-    VkVideoPictureResourceInfoKHR         srcPictureResource;
-    const VkVideoReferenceSlotInfoKHR*    pSetupReferenceSlot;
-    uint32_t                              referenceSlotCount;
-    const VkVideoReferenceSlotInfoKHR*    pReferenceSlots;
-    uint32_t                              precedingExternallyEncodedBytes;
-} VkVideoEncodeInfoKHR;
-
-typedef struct VkVideoEncodeCapabilitiesKHR {
-    VkStructureType                         sType;
-    void*                                   pNext;
-    VkVideoEncodeCapabilityFlagsKHR         flags;
-    VkVideoEncodeRateControlModeFlagsKHR    rateControlModes;
-    uint32_t                                maxRateControlLayers;
-    uint64_t                                maxBitrate;
-    uint32_t                                maxQualityLevels;
-    VkExtent2D                              encodeInputPictureGranularity;
-    VkVideoEncodeFeedbackFlagsKHR           supportedEncodeFeedbackFlags;
-} VkVideoEncodeCapabilitiesKHR;
-
-typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkVideoEncodeFeedbackFlagsKHR    encodeFeedbackFlags;
-} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR;
-
-typedef struct VkVideoEncodeUsageInfoKHR {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkVideoEncodeUsageFlagsKHR      videoUsageHints;
-    VkVideoEncodeContentFlagsKHR    videoContentHints;
-    VkVideoEncodeTuningModeKHR      tuningMode;
-} VkVideoEncodeUsageInfoKHR;
-
-typedef struct VkVideoEncodeRateControlLayerInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint64_t           averageBitrate;
-    uint64_t           maxBitrate;
-    uint32_t           frameRateNumerator;
-    uint32_t           frameRateDenominator;
-} VkVideoEncodeRateControlLayerInfoKHR;
-
-typedef struct VkVideoEncodeRateControlInfoKHR {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    VkVideoEncodeRateControlFlagsKHR               flags;
-    VkVideoEncodeRateControlModeFlagBitsKHR        rateControlMode;
-    uint32_t                                       layerCount;
-    const VkVideoEncodeRateControlLayerInfoKHR*    pLayers;
-    uint32_t                                       virtualBufferSizeInMs;
-    uint32_t                                       initialVirtualBufferSizeInMs;
-} VkVideoEncodeRateControlInfoKHR;
-
-typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    const VkVideoProfileInfoKHR*    pVideoProfile;
-    uint32_t                        qualityLevel;
-} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR;
-
-typedef struct VkVideoEncodeQualityLevelPropertiesKHR {
-    VkStructureType                            sType;
-    void*                                      pNext;
-    VkVideoEncodeRateControlModeFlagBitsKHR    preferredRateControlMode;
-    uint32_t                                   preferredRateControlLayerCount;
-} VkVideoEncodeQualityLevelPropertiesKHR;
-
-typedef struct VkVideoEncodeQualityLevelInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           qualityLevel;
-} VkVideoEncodeQualityLevelInfoKHR;
-
-typedef struct VkVideoEncodeSessionParametersGetInfoKHR {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkVideoSessionParametersKHR    videoSessionParameters;
-} VkVideoEncodeSessionParametersGetInfoKHR;
-
-typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           hasOverrides;
-} VkVideoEncodeSessionParametersFeedbackInfoKHR;
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData);
-typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo,
-    VkVideoEncodeQualityLevelPropertiesKHR*     pQualityLevelProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(
-    VkDevice                                    device,
-    const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo,
-    VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo,
-    size_t*                                     pDataSize,
-    void*                                       pData);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
-    VkCommandBuffer                             commandBuffer,
-    const VkVideoEncodeInfoKHR*                 pEncodeInfo);
-#endif
-
-
-// VK_EXT_video_encode_h264 is a preprocessor guard. Do not pass it to API calls.
-#define VK_EXT_video_encode_h264 1
-#include "vk_video/vulkan_video_codec_h264std.h"
-#include "vk_video/vulkan_video_codec_h264std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 12
-#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
-
-typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
-    VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264CapabilityFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
-
-typedef enum VkVideoEncodeH264StdFlagBitsEXT {
-    VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT = 0x00000200,
-    VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT = 0x00000400,
-    VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT = 0x00000800,
-    VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT = 0x00001000,
-    VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT = 0x00002000,
-    VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000,
-    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00008000,
-    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00010000,
-    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00020000,
-    VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT = 0x00080000,
-    VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT = 0x00100000,
-    VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264StdFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264StdFlagsEXT;
-
-typedef enum VkVideoEncodeH264RateControlFlagBitsEXT {
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264RateControlFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264RateControlFlagsEXT;
-typedef struct VkVideoEncodeH264CapabilitiesEXT {
-    VkStructureType                        sType;
-    void*                                  pNext;
-    VkVideoEncodeH264CapabilityFlagsEXT    flags;
-    StdVideoH264LevelIdc                   maxLevelIdc;
-    uint32_t                               maxSliceCount;
-    uint32_t                               maxPPictureL0ReferenceCount;
-    uint32_t                               maxBPictureL0ReferenceCount;
-    uint32_t                               maxL1ReferenceCount;
-    uint32_t                               maxTemporalLayerCount;
-    VkBool32                               expectDyadicTemporalLayerPattern;
-    int32_t                                minQp;
-    int32_t                                maxQp;
-    VkBool32                               prefersGopRemainingFrames;
-    VkBool32                               requiresGopRemainingFrames;
-    VkVideoEncodeH264StdFlagsEXT           stdSyntaxFlags;
-} VkVideoEncodeH264CapabilitiesEXT;
-
-typedef struct VkVideoEncodeH264QpEXT {
-    int32_t    qpI;
-    int32_t    qpP;
-    int32_t    qpB;
-} VkVideoEncodeH264QpEXT;
-
-typedef struct VkVideoEncodeH264QualityLevelPropertiesEXT {
-    VkStructureType                         sType;
-    void*                                   pNext;
-    VkVideoEncodeH264RateControlFlagsEXT    preferredRateControlFlags;
-    uint32_t                                preferredGopFrameCount;
-    uint32_t                                preferredIdrPeriod;
-    uint32_t                                preferredConsecutiveBFrameCount;
-    uint32_t                                preferredTemporalLayerCount;
-    VkVideoEncodeH264QpEXT                  preferredConstantQp;
-    uint32_t                                preferredMaxL0ReferenceCount;
-    uint32_t                                preferredMaxL1ReferenceCount;
-    VkBool32                                preferredStdEntropyCodingModeFlag;
-} VkVideoEncodeH264QualityLevelPropertiesEXT;
-
-typedef struct VkVideoEncodeH264SessionCreateInfoEXT {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkBool32                useMaxLevelIdc;
-    StdVideoH264LevelIdc    maxLevelIdc;
-} VkVideoEncodeH264SessionCreateInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {
-    VkStructureType                            sType;
-    const void*                                pNext;
-    uint32_t                                   stdSPSCount;
-    const StdVideoH264SequenceParameterSet*    pStdSPSs;
-    uint32_t                                   stdPPSCount;
-    const StdVideoH264PictureParameterSet*     pStdPPSs;
-} VkVideoEncodeH264SessionParametersAddInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
-    VkStructureType                                        sType;
-    const void*                                            pNext;
-    uint32_t                                               maxStdSPSCount;
-    uint32_t                                               maxStdPPSCount;
-    const VkVideoEncodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;
-} VkVideoEncodeH264SessionParametersCreateInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersGetInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           writeStdSPS;
-    VkBool32           writeStdPPS;
-    uint32_t           stdSPSId;
-    uint32_t           stdPPSId;
-} VkVideoEncodeH264SessionParametersGetInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           hasStdSPSOverrides;
-    VkBool32           hasStdPPSOverrides;
-} VkVideoEncodeH264SessionParametersFeedbackInfoEXT;
-
-typedef struct VkVideoEncodeH264NaluSliceInfoEXT {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    int32_t                                 constantQp;
-    const StdVideoEncodeH264SliceHeader*    pStdSliceHeader;
-} VkVideoEncodeH264NaluSliceInfoEXT;
-
-typedef struct VkVideoEncodeH264PictureInfoEXT {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    uint32_t                                    naluSliceEntryCount;
-    const VkVideoEncodeH264NaluSliceInfoEXT*    pNaluSliceEntries;
-    const StdVideoEncodeH264PictureInfo*        pStdPictureInfo;
-    VkBool32                                    generatePrefixNalu;
-} VkVideoEncodeH264PictureInfoEXT;
-
-typedef struct VkVideoEncodeH264DpbSlotInfoEXT {
-    VkStructureType                           sType;
-    const void*                               pNext;
-    const StdVideoEncodeH264ReferenceInfo*    pStdReferenceInfo;
-} VkVideoEncodeH264DpbSlotInfoEXT;
-
-typedef struct VkVideoEncodeH264ProfileInfoEXT {
-    VkStructureType           sType;
-    const void*               pNext;
-    StdVideoH264ProfileIdc    stdProfileIdc;
-} VkVideoEncodeH264ProfileInfoEXT;
-
-typedef struct VkVideoEncodeH264RateControlInfoEXT {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkVideoEncodeH264RateControlFlagsEXT    flags;
-    uint32_t                                gopFrameCount;
-    uint32_t                                idrPeriod;
-    uint32_t                                consecutiveBFrameCount;
-    uint32_t                                temporalLayerCount;
-} VkVideoEncodeH264RateControlInfoEXT;
-
-typedef struct VkVideoEncodeH264FrameSizeEXT {
-    uint32_t    frameISize;
-    uint32_t    framePSize;
-    uint32_t    frameBSize;
-} VkVideoEncodeH264FrameSizeEXT;
-
-typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkBool32                         useMinQp;
-    VkVideoEncodeH264QpEXT           minQp;
-    VkBool32                         useMaxQp;
-    VkVideoEncodeH264QpEXT           maxQp;
-    VkBool32                         useMaxFrameSize;
-    VkVideoEncodeH264FrameSizeEXT    maxFrameSize;
-} VkVideoEncodeH264RateControlLayerInfoEXT;
-
-typedef struct VkVideoEncodeH264GopRemainingFrameInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           useGopRemainingFrames;
-    uint32_t           gopRemainingI;
-    uint32_t           gopRemainingP;
-    uint32_t           gopRemainingB;
-} VkVideoEncodeH264GopRemainingFrameInfoEXT;
-
-
-
-// VK_EXT_video_encode_h265 is a preprocessor guard. Do not pass it to API calls.
-#define VK_EXT_video_encode_h265 1
-#include "vk_video/vulkan_video_codec_h265std.h"
-#include "vk_video/vulkan_video_codec_h265std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 12
-#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
-
-typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT = 0x00000200,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265CapabilityFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT;
-
-typedef enum VkVideoEncodeH265StdFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT = 0x00000200,
-    VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT = 0x00000400,
-    VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT = 0x00000800,
-    VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT = 0x00001000,
-    VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT = 0x00002000,
-    VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000,
-    VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT = 0x00008000,
-    VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT = 0x00010000,
-    VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT = 0x00020000,
-    VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT = 0x00040000,
-    VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT = 0x00080000,
-    VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT = 0x00100000,
-    VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265StdFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265StdFlagsEXT;
-
-typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265CtbSizeFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT;
-
-typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265TransformBlockSizeFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT;
-
-typedef enum VkVideoEncodeH265RateControlFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265RateControlFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265RateControlFlagsEXT;
-typedef struct VkVideoEncodeH265CapabilitiesEXT {
-    VkStructureType                                sType;
-    void*                                          pNext;
-    VkVideoEncodeH265CapabilityFlagsEXT            flags;
-    StdVideoH265LevelIdc                           maxLevelIdc;
-    uint32_t                                       maxSliceSegmentCount;
-    VkExtent2D                                     maxTiles;
-    VkVideoEncodeH265CtbSizeFlagsEXT               ctbSizes;
-    VkVideoEncodeH265TransformBlockSizeFlagsEXT    transformBlockSizes;
-    uint32_t                                       maxPPictureL0ReferenceCount;
-    uint32_t                                       maxBPictureL0ReferenceCount;
-    uint32_t                                       maxL1ReferenceCount;
-    uint32_t                                       maxSubLayerCount;
-    VkBool32                                       expectDyadicTemporalSubLayerPattern;
-    int32_t                                        minQp;
-    int32_t                                        maxQp;
-    VkBool32                                       prefersGopRemainingFrames;
-    VkBool32                                       requiresGopRemainingFrames;
-    VkVideoEncodeH265StdFlagsEXT                   stdSyntaxFlags;
-} VkVideoEncodeH265CapabilitiesEXT;
-
-typedef struct VkVideoEncodeH265SessionCreateInfoEXT {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkBool32                useMaxLevelIdc;
-    StdVideoH265LevelIdc    maxLevelIdc;
-} VkVideoEncodeH265SessionCreateInfoEXT;
-
-typedef struct VkVideoEncodeH265QpEXT {
-    int32_t    qpI;
-    int32_t    qpP;
-    int32_t    qpB;
-} VkVideoEncodeH265QpEXT;
-
-typedef struct VkVideoEncodeH265QualityLevelPropertiesEXT {
-    VkStructureType                         sType;
-    void*                                   pNext;
-    VkVideoEncodeH265RateControlFlagsEXT    preferredRateControlFlags;
-    uint32_t                                preferredGopFrameCount;
-    uint32_t                                preferredIdrPeriod;
-    uint32_t                                preferredConsecutiveBFrameCount;
-    uint32_t                                preferredSubLayerCount;
-    VkVideoEncodeH265QpEXT                  preferredConstantQp;
-    uint32_t                                preferredMaxL0ReferenceCount;
-    uint32_t                                preferredMaxL1ReferenceCount;
-} VkVideoEncodeH265QualityLevelPropertiesEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT {
-    VkStructureType                            sType;
-    const void*                                pNext;
-    uint32_t                                   stdVPSCount;
-    const StdVideoH265VideoParameterSet*       pStdVPSs;
-    uint32_t                                   stdSPSCount;
-    const StdVideoH265SequenceParameterSet*    pStdSPSs;
-    uint32_t                                   stdPPSCount;
-    const StdVideoH265PictureParameterSet*     pStdPPSs;
-} VkVideoEncodeH265SessionParametersAddInfoEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT {
-    VkStructureType                                        sType;
-    const void*                                            pNext;
-    uint32_t                                               maxStdVPSCount;
-    uint32_t                                               maxStdSPSCount;
-    uint32_t                                               maxStdPPSCount;
-    const VkVideoEncodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;
-} VkVideoEncodeH265SessionParametersCreateInfoEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersGetInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           writeStdVPS;
-    VkBool32           writeStdSPS;
-    VkBool32           writeStdPPS;
-    uint32_t           stdVPSId;
-    uint32_t           stdSPSId;
-    uint32_t           stdPPSId;
-} VkVideoEncodeH265SessionParametersGetInfoEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           hasStdVPSOverrides;
-    VkBool32           hasStdSPSOverrides;
-    VkBool32           hasStdPPSOverrides;
-} VkVideoEncodeH265SessionParametersFeedbackInfoEXT;
-
-typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    int32_t                                        constantQp;
-    const StdVideoEncodeH265SliceSegmentHeader*    pStdSliceSegmentHeader;
-} VkVideoEncodeH265NaluSliceSegmentInfoEXT;
-
-typedef struct VkVideoEncodeH265PictureInfoEXT {
-    VkStructureType                                    sType;
-    const void*                                        pNext;
-    uint32_t                                           naluSliceSegmentEntryCount;
-    const VkVideoEncodeH265NaluSliceSegmentInfoEXT*    pNaluSliceSegmentEntries;
-    const StdVideoEncodeH265PictureInfo*               pStdPictureInfo;
-} VkVideoEncodeH265PictureInfoEXT;
-
-typedef struct VkVideoEncodeH265DpbSlotInfoEXT {
-    VkStructureType                           sType;
-    const void*                               pNext;
-    const StdVideoEncodeH265ReferenceInfo*    pStdReferenceInfo;
-} VkVideoEncodeH265DpbSlotInfoEXT;
-
-typedef struct VkVideoEncodeH265ProfileInfoEXT {
-    VkStructureType           sType;
-    const void*               pNext;
-    StdVideoH265ProfileIdc    stdProfileIdc;
-} VkVideoEncodeH265ProfileInfoEXT;
-
-typedef struct VkVideoEncodeH265RateControlInfoEXT {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkVideoEncodeH265RateControlFlagsEXT    flags;
-    uint32_t                                gopFrameCount;
-    uint32_t                                idrPeriod;
-    uint32_t                                consecutiveBFrameCount;
-    uint32_t                                subLayerCount;
-} VkVideoEncodeH265RateControlInfoEXT;
-
-typedef struct VkVideoEncodeH265FrameSizeEXT {
-    uint32_t    frameISize;
-    uint32_t    framePSize;
-    uint32_t    frameBSize;
-} VkVideoEncodeH265FrameSizeEXT;
-
-typedef struct VkVideoEncodeH265RateControlLayerInfoEXT {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkBool32                         useMinQp;
-    VkVideoEncodeH265QpEXT           minQp;
-    VkBool32                         useMaxQp;
-    VkVideoEncodeH265QpEXT           maxQp;
-    VkBool32                         useMaxFrameSize;
-    VkVideoEncodeH265FrameSizeEXT    maxFrameSize;
-} VkVideoEncodeH265RateControlLayerInfoEXT;
-
-typedef struct VkVideoEncodeH265GopRemainingFrameInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           useGopRemainingFrames;
-    uint32_t           gopRemainingI;
-    uint32_t           gopRemainingP;
-    uint32_t           gopRemainingB;
-} VkVideoEncodeH265GopRemainingFrameInfoEXT;
-
-
-
 // VK_AMDX_shader_enqueue is a preprocessor guard. Do not pass it to API calls.
 #define VK_AMDX_shader_enqueue 1
 #define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 1
diff --git a/WickedEngine/Utility/vulkan/vulkan_core.h b/WickedEngine/Utility/vulkan/vulkan_core.h
index e19dd1b83..62b079c83 100644
--- a/WickedEngine/Utility/vulkan/vulkan_core.h
+++ b/WickedEngine/Utility/vulkan/vulkan_core.h
@@ -2,7 +2,7 @@
 #define VULKAN_CORE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -69,7 +69,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 272
+#define VK_HEADER_VERSION 290
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -182,11 +182,9 @@ typedef enum VkResult {
     VK_THREAD_DONE_KHR = 1000268001,
     VK_OPERATION_DEFERRED_KHR = 1000268002,
     VK_OPERATION_NOT_DEFERRED_KHR = 1000268003,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000,
-#endif
     VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000,
-    VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000,
+    VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000,
     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
     VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,
@@ -195,6 +193,7 @@ typedef enum VkResult {
     VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,
     VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,
     VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,
+    VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT,
     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 } VkResult;
 
@@ -467,90 +466,34 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT = 1000038003,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT = 1000038006,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT = 1000038010,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT = 1000038011,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT = 1000038012,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT = 1000038013,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT = 1000039003,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT = 1000039006,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT = 1000039011,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT = 1000039012,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT = 1000039013,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT = 1000039014,
-#endif
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR = 1000038000,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000038001,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000038002,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR = 1000038003,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR = 1000038004,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR = 1000038005,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR = 1000038006,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR = 1000038007,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR = 1000038008,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR = 1000038009,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR = 1000038010,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR = 1000038011,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR = 1000038012,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000038013,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR = 1000039000,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000039001,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000039002,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR = 1000039003,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR = 1000039004,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR = 1000039005,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR = 1000039006,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR = 1000039007,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR = 1000039009,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR = 1000039010,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR = 1000039011,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR = 1000039012,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR = 1000039013,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000039014,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003,
@@ -733,7 +676,6 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
     VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
-    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001,
@@ -746,8 +688,6 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001,
     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
-    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
     VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
@@ -779,7 +719,11 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = 1000232000,
+    VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = 1000232001,
+    VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = 1000232002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
@@ -804,11 +748,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
     VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
     VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
-    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
     VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
@@ -828,6 +768,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009,
     VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000,
     VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT = 1000272000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001,
+    VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,
     VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000,
     VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001,
@@ -868,39 +811,17 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002,
     VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299006,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR = 1000299007,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299008,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR = 1000299009,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010,
-#endif
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
     VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,
     VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000,
@@ -1042,6 +963,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = 1000416000,
     VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002,
@@ -1068,6 +990,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001,
     VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001,
@@ -1123,6 +1046,8 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000,
     VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT = 1000495000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT = 1000495001,
     VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT = 1000496000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001,
@@ -1142,6 +1067,14 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000,
     VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000,
+    VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001,
     VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002,
@@ -1152,13 +1085,45 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = 1000525000,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = 1000190001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = 1000190002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = 1000528000,
     VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000,
     VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001,
     VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002,
     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = 1000265000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = 1000259000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = 1000259001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = 1000259002,
+    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = 1000544000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = 1000545000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = 1000545001,
+    VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = 1000545002,
+    VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR = 1000545003,
+    VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = 1000545004,
+    VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = 1000545005,
+    VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = 1000545006,
+    VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007,
+    VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR = 1000562000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR = 1000562001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR = 1000562002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR = 1000562003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR = 1000562004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001,
+    VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -1259,6 +1224,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
+    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR,
     VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
@@ -1291,7 +1259,11 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
     VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES,
@@ -1368,15 +1340,10 @@ typedef enum VkImageLayout {
     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
     VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = 1000232000,
     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,
-#endif
     VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000,
     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
@@ -1449,6 +1416,7 @@ typedef enum VkObjectType {
 } VkObjectType;
 
 typedef enum VkVendorId {
+    VK_VENDOR_ID_KHRONOS = 0x10000,
     VK_VENDOR_ID_VIV = 0x10001,
     VK_VENDOR_ID_VSI = 0x10002,
     VK_VENDOR_ID_KAZAN = 0x10003,
@@ -1721,7 +1689,7 @@ typedef enum VkFormat {
     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
-    VK_FORMAT_R16G16_S10_5_NV = 1000464000,
+    VK_FORMAT_R16G16_SFIXED5_NV = 1000464000,
     VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = 1000470000,
     VK_FORMAT_A8_UNORM_KHR = 1000470001,
     VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,
@@ -1778,6 +1746,7 @@ typedef enum VkFormat {
     VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM,
     VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16,
     VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16,
+    VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV,
     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 } VkFormat;
 
@@ -1815,9 +1784,7 @@ typedef enum VkQueryType {
     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001,
     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
     VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000,
-#endif
     VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000,
     VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000,
     VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000,
@@ -1981,12 +1948,10 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000,
     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,
     VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,
-    VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,
     VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,
     VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,
     VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,
     VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,
-    VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
     VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003,
     VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004,
     VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005,
@@ -1997,6 +1962,7 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010,
     VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011,
     VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012,
+    VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002,
     VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013,
     VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014,
     VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015,
@@ -2018,6 +1984,8 @@ typedef enum VkDynamicState {
     VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031,
     VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
     VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000,
+    VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = 1000259000,
+    VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR,
     VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,
     VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,
     VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
@@ -2166,7 +2134,8 @@ typedef enum VkAttachmentLoadOp {
     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
-    VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000,
+    VK_ATTACHMENT_LOAD_OP_NONE_KHR = 1000400000,
+    VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE_KHR,
     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
 } VkAttachmentLoadOp;
 
@@ -2202,15 +2171,17 @@ typedef enum VkIndexType {
     VK_INDEX_TYPE_UINT16 = 0,
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_NONE_KHR = 1000165000,
-    VK_INDEX_TYPE_UINT8_EXT = 1000265000,
+    VK_INDEX_TYPE_UINT8_KHR = 1000265000,
     VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,
+    VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8_KHR,
     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkIndexType;
 
 typedef enum VkSubpassContents {
     VK_SUBPASS_CONTENTS_INLINE = 0,
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
-    VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = 1000451000,
+    VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR = 1000451000,
+    VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR,
     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
 } VkSubpassContents;
 
@@ -2303,12 +2274,8 @@ typedef enum VkFormatFeatureFlagBits {
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000,
     VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,
     VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000,
-#endif
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT,
     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
@@ -2344,6 +2311,7 @@ typedef enum VkImageCreateFlagBits {
     VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000,
     VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,
     VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000,
+    VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000,
     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
@@ -2381,15 +2349,9 @@ typedef enum VkImageUsageFlagBits {
     VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,
     VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100,
     VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = 0x00400000,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000,
-#endif
     VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000,
     VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000,
     VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000,
@@ -2434,9 +2396,7 @@ typedef enum VkQueueFlagBits {
     VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
     VK_QUEUE_PROTECTED_BIT = 0x00000010,
     VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040,
-#endif
     VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100,
     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkQueueFlagBits;
@@ -2486,6 +2446,11 @@ typedef enum VkPipelineStageFlagBits {
     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkPipelineStageFlagBits;
 typedef VkFlags VkPipelineStageFlags;
+
+typedef enum VkMemoryMapFlagBits {
+    VK_MEMORY_MAP_PLACED_BIT_EXT = 0x00000001,
+    VK_MEMORY_MAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkMemoryMapFlagBits;
 typedef VkFlags VkMemoryMapFlags;
 
 typedef enum VkSparseMemoryBindFlagBits {
@@ -2553,6 +2518,7 @@ typedef enum VkBufferCreateFlagBits {
     VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010,
     VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020,
+    VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00000040,
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,
     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
@@ -2581,12 +2547,8 @@ typedef enum VkBufferUsageFlagBits {
     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000,
     VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000,
     VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000,
-#endif
     VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000,
     VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000,
     VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000,
@@ -2778,6 +2740,7 @@ typedef enum VkDescriptorSetLayoutCreateFlagBits {
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV = 0x00000040,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
@@ -5007,6 +4970,8 @@ typedef enum VkSubgroupFeatureFlagBits {
     VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
     VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
+    VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = 0x00000200,
+    VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = 0x00000400,
     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkSubgroupFeatureFlagBits;
 typedef VkFlags VkSubgroupFeatureFlags;
@@ -5834,7 +5799,8 @@ typedef enum VkDriverId {
     VK_DRIVER_ID_MESA_DOZEN = 23,
     VK_DRIVER_ID_MESA_NVK = 24,
     VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25,
-    VK_DRIVER_ID_MESA_AGXV = 26,
+    VK_DRIVER_ID_MESA_HONEYKRISP = 26,
+    VK_DRIVER_ID_RESERVED_27 = 27,
     VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
     VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,
@@ -6651,9 +6617,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL;
-#endif
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL;
@@ -6724,12 +6688,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x40000000
 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;
-#endif
 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL;
@@ -6764,11 +6724,12 @@ typedef enum VkRenderingFlagBits {
     VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001,
     VK_RENDERING_SUSPENDING_BIT = 0x00000002,
     VK_RENDERING_RESUMING_BIT = 0x00000004,
-    VK_RENDERING_CONTENTS_INLINE_BIT_EXT = 0x00000010,
     VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008,
+    VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 0x00000010,
     VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
     VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT,
     VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT,
+    VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR,
     VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkRenderingFlagBits;
 typedef VkFlags VkRenderingFlags;
@@ -6836,12 +6797,8 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL;
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL;
-#endif
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL;
@@ -8052,14 +8009,11 @@ typedef enum VkQueryResultStatusKHR {
 
 typedef enum VkVideoCodecOperationFlagBitsKHR {
     VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0x00020000,
-#endif
+    VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR = 0x00010000,
+    VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000,
     VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001,
     VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002,
+    VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004,
     VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoCodecOperationFlagBitsKHR;
 typedef VkFlags VkVideoCodecOperationFlagsKHR;
@@ -8092,9 +8046,8 @@ typedef VkFlags VkVideoCapabilityFlagsKHR;
 
 typedef enum VkVideoSessionCreateFlagBitsKHR {
     VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR = 0x00000002,
-#endif
+    VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 0x00000004,
     VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoSessionCreateFlagBitsKHR;
 typedef VkFlags VkVideoSessionCreateFlagsKHR;
@@ -8104,12 +8057,8 @@ typedef VkFlags VkVideoEndCodingFlagsKHR;
 
 typedef enum VkVideoCodingControlFlagBitsKHR {
     VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001,
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002,
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR = 0x00000004,
-#endif
     VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkVideoCodingControlFlagBitsKHR;
 typedef VkFlags VkVideoCodingControlFlagsKHR;
@@ -8334,7 +8283,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(
 
 // VK_KHR_video_decode_queue is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_video_decode_queue 1
-#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 7
+#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 8
 #define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue"
 
 typedef enum VkVideoDecodeCapabilityFlagBitsKHR {
@@ -8387,11 +8336,434 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(
 #endif
 
 
+// VK_KHR_video_encode_h264 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_video_encode_h264 1
+#include "vk_video/vulkan_video_codec_h264std.h"
+#include "vk_video/vulkan_video_codec_h264std_encode.h"
+#define VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION 14
+#define VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_KHR_video_encode_h264"
+
+typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR {
+    VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 0x00000080,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 0x00000100,
+    VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH264CapabilityFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH264CapabilityFlagsKHR;
+
+typedef enum VkVideoEncodeH264StdFlagBitsKHR {
+    VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000010,
+    VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR = 0x00000020,
+    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040,
+    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR = 0x00000080,
+    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR = 0x00000100,
+    VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR = 0x00000200,
+    VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR = 0x00000400,
+    VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR = 0x00000800,
+    VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR = 0x00001000,
+    VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR = 0x00002000,
+    VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000,
+    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR = 0x00008000,
+    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR = 0x00010000,
+    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR = 0x00020000,
+    VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000,
+    VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000,
+    VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH264StdFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH264StdFlagsKHR;
+
+typedef enum VkVideoEncodeH264RateControlFlagBitsKHR {
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010,
+    VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH264RateControlFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH264RateControlFlagsKHR;
+typedef struct VkVideoEncodeH264CapabilitiesKHR {
+    VkStructureType                        sType;
+    void*                                  pNext;
+    VkVideoEncodeH264CapabilityFlagsKHR    flags;
+    StdVideoH264LevelIdc                   maxLevelIdc;
+    uint32_t                               maxSliceCount;
+    uint32_t                               maxPPictureL0ReferenceCount;
+    uint32_t                               maxBPictureL0ReferenceCount;
+    uint32_t                               maxL1ReferenceCount;
+    uint32_t                               maxTemporalLayerCount;
+    VkBool32                               expectDyadicTemporalLayerPattern;
+    int32_t                                minQp;
+    int32_t                                maxQp;
+    VkBool32                               prefersGopRemainingFrames;
+    VkBool32                               requiresGopRemainingFrames;
+    VkVideoEncodeH264StdFlagsKHR           stdSyntaxFlags;
+} VkVideoEncodeH264CapabilitiesKHR;
+
+typedef struct VkVideoEncodeH264QpKHR {
+    int32_t    qpI;
+    int32_t    qpP;
+    int32_t    qpB;
+} VkVideoEncodeH264QpKHR;
+
+typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR {
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkVideoEncodeH264RateControlFlagsKHR    preferredRateControlFlags;
+    uint32_t                                preferredGopFrameCount;
+    uint32_t                                preferredIdrPeriod;
+    uint32_t                                preferredConsecutiveBFrameCount;
+    uint32_t                                preferredTemporalLayerCount;
+    VkVideoEncodeH264QpKHR                  preferredConstantQp;
+    uint32_t                                preferredMaxL0ReferenceCount;
+    uint32_t                                preferredMaxL1ReferenceCount;
+    VkBool32                                preferredStdEntropyCodingModeFlag;
+} VkVideoEncodeH264QualityLevelPropertiesKHR;
+
+typedef struct VkVideoEncodeH264SessionCreateInfoKHR {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkBool32                useMaxLevelIdc;
+    StdVideoH264LevelIdc    maxLevelIdc;
+} VkVideoEncodeH264SessionCreateInfoKHR;
+
+typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH264SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH264PictureParameterSet*     pStdPPSs;
+} VkVideoEncodeH264SessionParametersAddInfoKHR;
+
+typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
+    const VkVideoEncodeH264SessionParametersAddInfoKHR*    pParametersAddInfo;
+} VkVideoEncodeH264SessionParametersCreateInfoKHR;
+
+typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           writeStdSPS;
+    VkBool32           writeStdPPS;
+    uint32_t           stdSPSId;
+    uint32_t           stdPPSId;
+} VkVideoEncodeH264SessionParametersGetInfoKHR;
+
+typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           hasStdSPSOverrides;
+    VkBool32           hasStdPPSOverrides;
+} VkVideoEncodeH264SessionParametersFeedbackInfoKHR;
+
+typedef struct VkVideoEncodeH264NaluSliceInfoKHR {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    int32_t                                 constantQp;
+    const StdVideoEncodeH264SliceHeader*    pStdSliceHeader;
+} VkVideoEncodeH264NaluSliceInfoKHR;
+
+typedef struct VkVideoEncodeH264PictureInfoKHR {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    naluSliceEntryCount;
+    const VkVideoEncodeH264NaluSliceInfoKHR*    pNaluSliceEntries;
+    const StdVideoEncodeH264PictureInfo*        pStdPictureInfo;
+    VkBool32                                    generatePrefixNalu;
+} VkVideoEncodeH264PictureInfoKHR;
+
+typedef struct VkVideoEncodeH264DpbSlotInfoKHR {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    const StdVideoEncodeH264ReferenceInfo*    pStdReferenceInfo;
+} VkVideoEncodeH264DpbSlotInfoKHR;
+
+typedef struct VkVideoEncodeH264ProfileInfoKHR {
+    VkStructureType           sType;
+    const void*               pNext;
+    StdVideoH264ProfileIdc    stdProfileIdc;
+} VkVideoEncodeH264ProfileInfoKHR;
+
+typedef struct VkVideoEncodeH264RateControlInfoKHR {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkVideoEncodeH264RateControlFlagsKHR    flags;
+    uint32_t                                gopFrameCount;
+    uint32_t                                idrPeriod;
+    uint32_t                                consecutiveBFrameCount;
+    uint32_t                                temporalLayerCount;
+} VkVideoEncodeH264RateControlInfoKHR;
+
+typedef struct VkVideoEncodeH264FrameSizeKHR {
+    uint32_t    frameISize;
+    uint32_t    framePSize;
+    uint32_t    frameBSize;
+} VkVideoEncodeH264FrameSizeKHR;
+
+typedef struct VkVideoEncodeH264RateControlLayerInfoKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkBool32                         useMinQp;
+    VkVideoEncodeH264QpKHR           minQp;
+    VkBool32                         useMaxQp;
+    VkVideoEncodeH264QpKHR           maxQp;
+    VkBool32                         useMaxFrameSize;
+    VkVideoEncodeH264FrameSizeKHR    maxFrameSize;
+} VkVideoEncodeH264RateControlLayerInfoKHR;
+
+typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           useGopRemainingFrames;
+    uint32_t           gopRemainingI;
+    uint32_t           gopRemainingP;
+    uint32_t           gopRemainingB;
+} VkVideoEncodeH264GopRemainingFrameInfoKHR;
+
+
+
+// VK_KHR_video_encode_h265 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_video_encode_h265 1
+#include "vk_video/vulkan_video_codec_h265std.h"
+#include "vk_video/vulkan_video_codec_h265std_encode.h"
+#define VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION 14
+#define VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_KHR_video_encode_h265"
+
+typedef enum VkVideoEncodeH265CapabilityFlagBitsKHR {
+    VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR = 0x00000080,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR = 0x00000100,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR = 0x00000200,
+    VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH265CapabilityFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH265CapabilityFlagsKHR;
+
+typedef enum VkVideoEncodeH265StdFlagBitsKHR {
+    VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR = 0x00000010,
+    VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR = 0x00000020,
+    VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040,
+    VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR = 0x00000080,
+    VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR = 0x00000100,
+    VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR = 0x00000200,
+    VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR = 0x00000400,
+    VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR = 0x00000800,
+    VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR = 0x00001000,
+    VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR = 0x00002000,
+    VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000,
+    VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR = 0x00008000,
+    VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR = 0x00010000,
+    VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR = 0x00020000,
+    VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR = 0x00040000,
+    VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000,
+    VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000,
+    VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH265StdFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH265StdFlagsKHR;
+
+typedef enum VkVideoEncodeH265CtbSizeFlagBitsKHR {
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH265CtbSizeFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR;
+
+typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsKHR {
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH265TransformBlockSizeFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR;
+
+typedef enum VkVideoEncodeH265RateControlFlagBitsKHR {
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010,
+    VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeH265RateControlFlagBitsKHR;
+typedef VkFlags VkVideoEncodeH265RateControlFlagsKHR;
+typedef struct VkVideoEncodeH265CapabilitiesKHR {
+    VkStructureType                                sType;
+    void*                                          pNext;
+    VkVideoEncodeH265CapabilityFlagsKHR            flags;
+    StdVideoH265LevelIdc                           maxLevelIdc;
+    uint32_t                                       maxSliceSegmentCount;
+    VkExtent2D                                     maxTiles;
+    VkVideoEncodeH265CtbSizeFlagsKHR               ctbSizes;
+    VkVideoEncodeH265TransformBlockSizeFlagsKHR    transformBlockSizes;
+    uint32_t                                       maxPPictureL0ReferenceCount;
+    uint32_t                                       maxBPictureL0ReferenceCount;
+    uint32_t                                       maxL1ReferenceCount;
+    uint32_t                                       maxSubLayerCount;
+    VkBool32                                       expectDyadicTemporalSubLayerPattern;
+    int32_t                                        minQp;
+    int32_t                                        maxQp;
+    VkBool32                                       prefersGopRemainingFrames;
+    VkBool32                                       requiresGopRemainingFrames;
+    VkVideoEncodeH265StdFlagsKHR                   stdSyntaxFlags;
+} VkVideoEncodeH265CapabilitiesKHR;
+
+typedef struct VkVideoEncodeH265SessionCreateInfoKHR {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkBool32                useMaxLevelIdc;
+    StdVideoH265LevelIdc    maxLevelIdc;
+} VkVideoEncodeH265SessionCreateInfoKHR;
+
+typedef struct VkVideoEncodeH265QpKHR {
+    int32_t    qpI;
+    int32_t    qpP;
+    int32_t    qpB;
+} VkVideoEncodeH265QpKHR;
+
+typedef struct VkVideoEncodeH265QualityLevelPropertiesKHR {
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkVideoEncodeH265RateControlFlagsKHR    preferredRateControlFlags;
+    uint32_t                                preferredGopFrameCount;
+    uint32_t                                preferredIdrPeriod;
+    uint32_t                                preferredConsecutiveBFrameCount;
+    uint32_t                                preferredSubLayerCount;
+    VkVideoEncodeH265QpKHR                  preferredConstantQp;
+    uint32_t                                preferredMaxL0ReferenceCount;
+    uint32_t                                preferredMaxL1ReferenceCount;
+} VkVideoEncodeH265QualityLevelPropertiesKHR;
+
+typedef struct VkVideoEncodeH265SessionParametersAddInfoKHR {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   stdVPSCount;
+    const StdVideoH265VideoParameterSet*       pStdVPSs;
+    uint32_t                                   stdSPSCount;
+    const StdVideoH265SequenceParameterSet*    pStdSPSs;
+    uint32_t                                   stdPPSCount;
+    const StdVideoH265PictureParameterSet*     pStdPPSs;
+} VkVideoEncodeH265SessionParametersAddInfoKHR;
+
+typedef struct VkVideoEncodeH265SessionParametersCreateInfoKHR {
+    VkStructureType                                        sType;
+    const void*                                            pNext;
+    uint32_t                                               maxStdVPSCount;
+    uint32_t                                               maxStdSPSCount;
+    uint32_t                                               maxStdPPSCount;
+    const VkVideoEncodeH265SessionParametersAddInfoKHR*    pParametersAddInfo;
+} VkVideoEncodeH265SessionParametersCreateInfoKHR;
+
+typedef struct VkVideoEncodeH265SessionParametersGetInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           writeStdVPS;
+    VkBool32           writeStdSPS;
+    VkBool32           writeStdPPS;
+    uint32_t           stdVPSId;
+    uint32_t           stdSPSId;
+    uint32_t           stdPPSId;
+} VkVideoEncodeH265SessionParametersGetInfoKHR;
+
+typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           hasStdVPSOverrides;
+    VkBool32           hasStdSPSOverrides;
+    VkBool32           hasStdPPSOverrides;
+} VkVideoEncodeH265SessionParametersFeedbackInfoKHR;
+
+typedef struct VkVideoEncodeH265NaluSliceSegmentInfoKHR {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    int32_t                                        constantQp;
+    const StdVideoEncodeH265SliceSegmentHeader*    pStdSliceSegmentHeader;
+} VkVideoEncodeH265NaluSliceSegmentInfoKHR;
+
+typedef struct VkVideoEncodeH265PictureInfoKHR {
+    VkStructureType                                    sType;
+    const void*                                        pNext;
+    uint32_t                                           naluSliceSegmentEntryCount;
+    const VkVideoEncodeH265NaluSliceSegmentInfoKHR*    pNaluSliceSegmentEntries;
+    const StdVideoEncodeH265PictureInfo*               pStdPictureInfo;
+} VkVideoEncodeH265PictureInfoKHR;
+
+typedef struct VkVideoEncodeH265DpbSlotInfoKHR {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    const StdVideoEncodeH265ReferenceInfo*    pStdReferenceInfo;
+} VkVideoEncodeH265DpbSlotInfoKHR;
+
+typedef struct VkVideoEncodeH265ProfileInfoKHR {
+    VkStructureType           sType;
+    const void*               pNext;
+    StdVideoH265ProfileIdc    stdProfileIdc;
+} VkVideoEncodeH265ProfileInfoKHR;
+
+typedef struct VkVideoEncodeH265RateControlInfoKHR {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkVideoEncodeH265RateControlFlagsKHR    flags;
+    uint32_t                                gopFrameCount;
+    uint32_t                                idrPeriod;
+    uint32_t                                consecutiveBFrameCount;
+    uint32_t                                subLayerCount;
+} VkVideoEncodeH265RateControlInfoKHR;
+
+typedef struct VkVideoEncodeH265FrameSizeKHR {
+    uint32_t    frameISize;
+    uint32_t    framePSize;
+    uint32_t    frameBSize;
+} VkVideoEncodeH265FrameSizeKHR;
+
+typedef struct VkVideoEncodeH265RateControlLayerInfoKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkBool32                         useMinQp;
+    VkVideoEncodeH265QpKHR           minQp;
+    VkBool32                         useMaxQp;
+    VkVideoEncodeH265QpKHR           maxQp;
+    VkBool32                         useMaxFrameSize;
+    VkVideoEncodeH265FrameSizeKHR    maxFrameSize;
+} VkVideoEncodeH265RateControlLayerInfoKHR;
+
+typedef struct VkVideoEncodeH265GopRemainingFrameInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           useGopRemainingFrames;
+    uint32_t           gopRemainingI;
+    uint32_t           gopRemainingP;
+    uint32_t           gopRemainingB;
+} VkVideoEncodeH265GopRemainingFrameInfoKHR;
+
+
+
 // VK_KHR_video_decode_h264 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_video_decode_h264 1
-#include "vk_video/vulkan_video_codec_h264std.h"
 #include "vk_video/vulkan_video_codec_h264std_decode.h"
-#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 8
+#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 9
 #define VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME "VK_KHR_video_decode_h264"
 
 typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR {
@@ -9605,9 +9977,8 @@ typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
 
 // VK_KHR_video_decode_h265 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_video_decode_h265 1
-#include "vk_video/vulkan_video_codec_h265std.h"
 #include "vk_video/vulkan_video_codec_h265std_decode.h"
-#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 7
+#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 8
 #define VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME "VK_KHR_video_decode_h265"
 typedef struct VkVideoDecodeH265ProfileInfoKHR {
     VkStructureType           sType;
@@ -9878,6 +10249,58 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(
 #endif
 
 
+// VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_dynamic_rendering_local_read 1
+#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1
+#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read"
+typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           dynamicRenderingLocalRead;
+} VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR;
+
+typedef struct VkRenderingAttachmentLocationInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           colorAttachmentCount;
+    const uint32_t*    pColorAttachmentLocations;
+} VkRenderingAttachmentLocationInfoKHR;
+
+typedef struct VkRenderingInputAttachmentIndexInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           colorAttachmentCount;
+    const uint32_t*    pColorAttachmentInputIndices;
+    const uint32_t*    pDepthInputAttachmentIndex;
+    const uint32_t*    pStencilInputAttachmentIndex;
+} VkRenderingInputAttachmentIndexInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderingAttachmentLocationInfoKHR* pLocationInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo);
+#endif
+
+
+// VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_quad_control 1
+#define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1
+#define VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME "VK_KHR_shader_quad_control"
+typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderQuadControl;
+} VkPhysicalDeviceShaderQuadControlFeaturesKHR;
+
+
+
 // VK_KHR_spirv_1_4 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_spirv_1_4 1
 #define VK_KHR_SPIRV_1_4_SPEC_VERSION     1
@@ -10101,6 +10524,11 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR
 #define VK_KHR_map_memory2 1
 #define VK_KHR_MAP_MEMORY_2_SPEC_VERSION  1
 #define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2"
+
+typedef enum VkMemoryUnmapFlagBitsKHR {
+    VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 0x00000001,
+    VK_MEMORY_UNMAP_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkMemoryUnmapFlagBitsKHR;
 typedef VkFlags VkMemoryUnmapFlagsKHR;
 typedef struct VkMemoryMapInfoKHR {
     VkStructureType     sType;
@@ -10181,6 +10609,183 @@ typedef struct VkPhysicalDevicePresentIdFeaturesKHR {
 
 
 
+// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_video_encode_queue 1
+#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 12
+#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
+
+typedef enum VkVideoEncodeTuningModeKHR {
+    VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1,
+    VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2,
+    VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3,
+    VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4,
+    VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeTuningModeKHR;
+
+typedef enum VkVideoEncodeFlagBitsKHR {
+    VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeFlagBitsKHR;
+typedef VkFlags VkVideoEncodeFlagsKHR;
+
+typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
+    VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeCapabilityFlagBitsKHR;
+typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
+
+typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeRateControlModeFlagBitsKHR;
+typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
+
+typedef enum VkVideoEncodeFeedbackFlagBitsKHR {
+    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeFeedbackFlagBitsKHR;
+typedef VkFlags VkVideoEncodeFeedbackFlagsKHR;
+
+typedef enum VkVideoEncodeUsageFlagBitsKHR {
+    VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008,
+    VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeUsageFlagBitsKHR;
+typedef VkFlags VkVideoEncodeUsageFlagsKHR;
+
+typedef enum VkVideoEncodeContentFlagBitsKHR {
+    VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0,
+    VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001,
+    VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002,
+    VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004,
+    VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoEncodeContentFlagBitsKHR;
+typedef VkFlags VkVideoEncodeContentFlagsKHR;
+typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
+typedef struct VkVideoEncodeInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkVideoEncodeFlagsKHR                 flags;
+    VkBuffer                              dstBuffer;
+    VkDeviceSize                          dstBufferOffset;
+    VkDeviceSize                          dstBufferRange;
+    VkVideoPictureResourceInfoKHR         srcPictureResource;
+    const VkVideoReferenceSlotInfoKHR*    pSetupReferenceSlot;
+    uint32_t                              referenceSlotCount;
+    const VkVideoReferenceSlotInfoKHR*    pReferenceSlots;
+    uint32_t                              precedingExternallyEncodedBytes;
+} VkVideoEncodeInfoKHR;
+
+typedef struct VkVideoEncodeCapabilitiesKHR {
+    VkStructureType                         sType;
+    void*                                   pNext;
+    VkVideoEncodeCapabilityFlagsKHR         flags;
+    VkVideoEncodeRateControlModeFlagsKHR    rateControlModes;
+    uint32_t                                maxRateControlLayers;
+    uint64_t                                maxBitrate;
+    uint32_t                                maxQualityLevels;
+    VkExtent2D                              encodeInputPictureGranularity;
+    VkVideoEncodeFeedbackFlagsKHR           supportedEncodeFeedbackFlags;
+} VkVideoEncodeCapabilitiesKHR;
+
+typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkVideoEncodeFeedbackFlagsKHR    encodeFeedbackFlags;
+} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR;
+
+typedef struct VkVideoEncodeUsageInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkVideoEncodeUsageFlagsKHR      videoUsageHints;
+    VkVideoEncodeContentFlagsKHR    videoContentHints;
+    VkVideoEncodeTuningModeKHR      tuningMode;
+} VkVideoEncodeUsageInfoKHR;
+
+typedef struct VkVideoEncodeRateControlLayerInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint64_t           averageBitrate;
+    uint64_t           maxBitrate;
+    uint32_t           frameRateNumerator;
+    uint32_t           frameRateDenominator;
+} VkVideoEncodeRateControlLayerInfoKHR;
+
+typedef struct VkVideoEncodeRateControlInfoKHR {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    VkVideoEncodeRateControlFlagsKHR               flags;
+    VkVideoEncodeRateControlModeFlagBitsKHR        rateControlMode;
+    uint32_t                                       layerCount;
+    const VkVideoEncodeRateControlLayerInfoKHR*    pLayers;
+    uint32_t                                       virtualBufferSizeInMs;
+    uint32_t                                       initialVirtualBufferSizeInMs;
+} VkVideoEncodeRateControlInfoKHR;
+
+typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    const VkVideoProfileInfoKHR*    pVideoProfile;
+    uint32_t                        qualityLevel;
+} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR;
+
+typedef struct VkVideoEncodeQualityLevelPropertiesKHR {
+    VkStructureType                            sType;
+    void*                                      pNext;
+    VkVideoEncodeRateControlModeFlagBitsKHR    preferredRateControlMode;
+    uint32_t                                   preferredRateControlLayerCount;
+} VkVideoEncodeQualityLevelPropertiesKHR;
+
+typedef struct VkVideoEncodeQualityLevelInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           qualityLevel;
+} VkVideoEncodeQualityLevelInfoKHR;
+
+typedef struct VkVideoEncodeSessionParametersGetInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkVideoSessionParametersKHR    videoSessionParameters;
+} VkVideoEncodeSessionParametersGetInfoKHR;
+
+typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           hasOverrides;
+} VkVideoEncodeSessionParametersFeedbackInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData);
+typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo,
+    VkVideoEncodeQualityLevelPropertiesKHR*     pQualityLevelProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(
+    VkDevice                                    device,
+    const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo,
+    VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo,
+    size_t*                                     pDataSize,
+    void*                                       pData);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkVideoEncodeInfoKHR*                 pEncodeInfo);
+#endif
+
+
 // VK_KHR_synchronization2 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_synchronization2 1
 #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1
@@ -10485,6 +11090,31 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(
 #endif
 
 
+// VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_subgroup_rotate 1
+#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2
+#define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate"
+typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderSubgroupRotate;
+    VkBool32           shaderSubgroupRotateClustered;
+} VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR;
+
+
+
+// VK_KHR_shader_maximal_reconvergence is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_maximal_reconvergence 1
+#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION 1
+#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME "VK_KHR_shader_maximal_reconvergence"
+typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderMaximalReconvergence;
+} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
+
+
+
 // VK_KHR_maintenance5 is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_maintenance5 1
 #define VK_KHR_MAINTENANCE_5_SPEC_VERSION 1
@@ -10496,6 +11126,7 @@ typedef VkFlags64 VkPipelineCreateFlagBits2KHR;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL;
+static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL;
@@ -10546,12 +11177,8 @@ static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFF
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL;
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000ULL;
-#endif
-#ifdef VK_ENABLE_BETA_EXTENSIONS
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000ULL;
-#endif
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL;
@@ -10741,6 +11368,423 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR
 #endif
 
 
+// VK_KHR_video_decode_av1 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_video_decode_av1 1
+#include "vk_video/vulkan_video_codec_av1std.h"
+#include "vk_video/vulkan_video_codec_av1std_decode.h"
+#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7U
+#define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1
+#define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1"
+typedef struct VkVideoDecodeAV1ProfileInfoKHR {
+    VkStructureType       sType;
+    const void*           pNext;
+    StdVideoAV1Profile    stdProfile;
+    VkBool32              filmGrainSupport;
+} VkVideoDecodeAV1ProfileInfoKHR;
+
+typedef struct VkVideoDecodeAV1CapabilitiesKHR {
+    VkStructureType     sType;
+    void*               pNext;
+    StdVideoAV1Level    maxLevel;
+} VkVideoDecodeAV1CapabilitiesKHR;
+
+typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    const StdVideoAV1SequenceHeader*    pStdSequenceHeader;
+} VkVideoDecodeAV1SessionParametersCreateInfoKHR;
+
+typedef struct VkVideoDecodeAV1PictureInfoKHR {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    const StdVideoDecodeAV1PictureInfo*    pStdPictureInfo;
+    int32_t                                referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
+    uint32_t                               frameHeaderOffset;
+    uint32_t                               tileCount;
+    const uint32_t*                        pTileOffsets;
+    const uint32_t*                        pTileSizes;
+} VkVideoDecodeAV1PictureInfoKHR;
+
+typedef struct VkVideoDecodeAV1DpbSlotInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    const StdVideoDecodeAV1ReferenceInfo*    pStdReferenceInfo;
+} VkVideoDecodeAV1DpbSlotInfoKHR;
+
+
+
+// VK_KHR_video_maintenance1 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_video_maintenance1 1
+#define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1
+#define VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_video_maintenance1"
+typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           videoMaintenance1;
+} VkPhysicalDeviceVideoMaintenance1FeaturesKHR;
+
+typedef struct VkVideoInlineQueryInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkQueryPool        queryPool;
+    uint32_t           firstQuery;
+    uint32_t           queryCount;
+} VkVideoInlineQueryInfoKHR;
+
+
+
+// VK_KHR_vertex_attribute_divisor is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_vertex_attribute_divisor 1
+#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1
+#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_KHR_vertex_attribute_divisor"
+typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxVertexAttribDivisor;
+    VkBool32           supportsNonZeroFirstInstance;
+} VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR;
+
+typedef struct VkVertexInputBindingDivisorDescriptionKHR {
+    uint32_t    binding;
+    uint32_t    divisor;
+} VkVertexInputBindingDivisorDescriptionKHR;
+
+typedef struct VkPipelineVertexInputDivisorStateCreateInfoKHR {
+    VkStructureType                                     sType;
+    const void*                                         pNext;
+    uint32_t                                            vertexBindingDivisorCount;
+    const VkVertexInputBindingDivisorDescriptionKHR*    pVertexBindingDivisors;
+} VkPipelineVertexInputDivisorStateCreateInfoKHR;
+
+typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           vertexAttributeInstanceRateDivisor;
+    VkBool32           vertexAttributeInstanceRateZeroDivisor;
+} VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR;
+
+
+
+// VK_KHR_load_store_op_none is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_load_store_op_none 1
+#define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1
+#define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none"
+
+
+// VK_KHR_shader_float_controls2 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_float_controls2 1
+#define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1
+#define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2"
+typedef struct VkPhysicalDeviceShaderFloatControls2FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderFloatControls2;
+} VkPhysicalDeviceShaderFloatControls2FeaturesKHR;
+
+
+
+// VK_KHR_index_type_uint8 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_index_type_uint8 1
+#define VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION 1
+#define VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_KHR_index_type_uint8"
+typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           indexTypeUint8;
+} VkPhysicalDeviceIndexTypeUint8FeaturesKHR;
+
+
+
+// VK_KHR_line_rasterization is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_line_rasterization 1
+#define VK_KHR_LINE_RASTERIZATION_SPEC_VERSION 1
+#define VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME "VK_KHR_line_rasterization"
+
+typedef enum VkLineRasterizationModeKHR {
+    VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = 0,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = 1,
+    VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = 2,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = 3,
+    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR,
+    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR,
+    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR,
+    VK_LINE_RASTERIZATION_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkLineRasterizationModeKHR;
+typedef struct VkPhysicalDeviceLineRasterizationFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rectangularLines;
+    VkBool32           bresenhamLines;
+    VkBool32           smoothLines;
+    VkBool32           stippledRectangularLines;
+    VkBool32           stippledBresenhamLines;
+    VkBool32           stippledSmoothLines;
+} VkPhysicalDeviceLineRasterizationFeaturesKHR;
+
+typedef struct VkPhysicalDeviceLineRasterizationPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           lineSubPixelPrecisionBits;
+} VkPhysicalDeviceLineRasterizationPropertiesKHR;
+
+typedef struct VkPipelineRasterizationLineStateCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkLineRasterizationModeKHR    lineRasterizationMode;
+    VkBool32                      stippledLineEnable;
+    uint32_t                      lineStippleFactor;
+    uint16_t                      lineStipplePattern;
+} VkPipelineRasterizationLineStateCreateInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
+#endif
+
+
+// VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_calibrated_timestamps 1
+#define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1
+#define VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_KHR_calibrated_timestamps"
+
+typedef enum VkTimeDomainKHR {
+    VK_TIME_DOMAIN_DEVICE_KHR = 0,
+    VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1,
+    VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2,
+    VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3,
+    VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR,
+    VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR,
+    VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR,
+    VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR,
+    VK_TIME_DOMAIN_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkTimeDomainKHR;
+typedef struct VkCalibratedTimestampInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkTimeDomainKHR    timeDomain;
+} VkCalibratedTimestampInfoKHR;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains);
+typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsKHR)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pTimeDomainCount,
+    VkTimeDomainKHR*                            pTimeDomains);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(
+    VkDevice                                    device,
+    uint32_t                                    timestampCount,
+    const VkCalibratedTimestampInfoKHR*         pTimestampInfos,
+    uint64_t*                                   pTimestamps,
+    uint64_t*                                   pMaxDeviation);
+#endif
+
+
+// VK_KHR_shader_expect_assume is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_expect_assume 1
+#define VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION 1
+#define VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME "VK_KHR_shader_expect_assume"
+typedef struct VkPhysicalDeviceShaderExpectAssumeFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderExpectAssume;
+} VkPhysicalDeviceShaderExpectAssumeFeaturesKHR;
+
+
+
+// VK_KHR_maintenance6 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_maintenance6 1
+#define VK_KHR_MAINTENANCE_6_SPEC_VERSION 1
+#define VK_KHR_MAINTENANCE_6_EXTENSION_NAME "VK_KHR_maintenance6"
+typedef struct VkPhysicalDeviceMaintenance6FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           maintenance6;
+} VkPhysicalDeviceMaintenance6FeaturesKHR;
+
+typedef struct VkPhysicalDeviceMaintenance6PropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           blockTexelViewCompatibleMultipleLayers;
+    uint32_t           maxCombinedImageSamplerDescriptorCount;
+    VkBool32           fragmentShadingRateClampCombinerInputs;
+} VkPhysicalDeviceMaintenance6PropertiesKHR;
+
+typedef struct VkBindMemoryStatusKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkResult*          pResult;
+} VkBindMemoryStatusKHR;
+
+typedef struct VkBindDescriptorSetsInfoKHR {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkShaderStageFlags        stageFlags;
+    VkPipelineLayout          layout;
+    uint32_t                  firstSet;
+    uint32_t                  descriptorSetCount;
+    const VkDescriptorSet*    pDescriptorSets;
+    uint32_t                  dynamicOffsetCount;
+    const uint32_t*           pDynamicOffsets;
+} VkBindDescriptorSetsInfoKHR;
+
+typedef struct VkPushConstantsInfoKHR {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkPipelineLayout      layout;
+    VkShaderStageFlags    stageFlags;
+    uint32_t              offset;
+    uint32_t              size;
+    const void*           pValues;
+} VkPushConstantsInfoKHR;
+
+typedef struct VkPushDescriptorSetInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkShaderStageFlags             stageFlags;
+    VkPipelineLayout               layout;
+    uint32_t                       set;
+    uint32_t                       descriptorWriteCount;
+    const VkWriteDescriptorSet*    pDescriptorWrites;
+} VkPushDescriptorSetInfoKHR;
+
+typedef struct VkPushDescriptorSetWithTemplateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkDescriptorUpdateTemplate    descriptorUpdateTemplate;
+    VkPipelineLayout              layout;
+    uint32_t                      set;
+    const void*                   pData;
+} VkPushDescriptorSetWithTemplateInfoKHR;
+
+typedef struct VkSetDescriptorBufferOffsetsInfoEXT {
+    VkStructureType        sType;
+    const void*            pNext;
+    VkShaderStageFlags     stageFlags;
+    VkPipelineLayout       layout;
+    uint32_t               firstSet;
+    uint32_t               setCount;
+    const uint32_t*        pBufferIndices;
+    const VkDeviceSize*    pOffsets;
+} VkSetDescriptorBufferOffsetsInfoEXT;
+
+typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkShaderStageFlags    stageFlags;
+    VkPipelineLayout      layout;
+    uint32_t              set;
+} VkBindDescriptorBufferEmbeddedSamplersInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2KHR)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2KHR)(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkBindDescriptorSetsInfoKHR*          pBindDescriptorSetsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkPushConstantsInfoKHR*               pPushConstantsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkPushDescriptorSetInfoKHR*           pPushDescriptorSetInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR(
+    VkCommandBuffer                             commandBuffer,
+    const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkSetDescriptorBufferOffsetsInfoEXT*  pSetDescriptorBufferOffsetsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo);
+#endif
+
+
+// VK_KHR_shader_relaxed_extended_instruction is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_relaxed_extended_instruction 1
+#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION 1
+#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME "VK_KHR_shader_relaxed_extended_instruction"
+typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderRelaxedExtendedInstruction;
+} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
+
+
+
+// VK_KHR_maintenance7 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_maintenance7 1
+#define VK_KHR_MAINTENANCE_7_SPEC_VERSION 1
+#define VK_KHR_MAINTENANCE_7_EXTENSION_NAME "VK_KHR_maintenance7"
+
+typedef enum VkPhysicalDeviceLayeredApiKHR {
+    VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR = 0,
+    VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR = 1,
+    VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR = 2,
+    VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR = 3,
+    VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR = 4,
+    VK_PHYSICAL_DEVICE_LAYERED_API_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPhysicalDeviceLayeredApiKHR;
+typedef struct VkPhysicalDeviceMaintenance7FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           maintenance7;
+} VkPhysicalDeviceMaintenance7FeaturesKHR;
+
+typedef struct VkPhysicalDeviceMaintenance7PropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           robustFragmentShadingRateAttachmentAccess;
+    VkBool32           separateDepthStencilAttachmentAccess;
+    uint32_t           maxDescriptorSetTotalUniformBuffersDynamic;
+    uint32_t           maxDescriptorSetTotalStorageBuffersDynamic;
+    uint32_t           maxDescriptorSetTotalBuffersDynamic;
+    uint32_t           maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic;
+    uint32_t           maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic;
+    uint32_t           maxDescriptorSetUpdateAfterBindTotalBuffersDynamic;
+} VkPhysicalDeviceMaintenance7PropertiesKHR;
+
+typedef struct VkPhysicalDeviceLayeredApiPropertiesKHR {
+    VkStructureType                  sType;
+    void*                            pNext;
+    uint32_t                         vendorID;
+    uint32_t                         deviceID;
+    VkPhysicalDeviceLayeredApiKHR    layeredAPI;
+    char                             deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+} VkPhysicalDeviceLayeredApiPropertiesKHR;
+
+typedef struct VkPhysicalDeviceLayeredApiPropertiesListKHR {
+    VkStructureType                             sType;
+    void*                                       pNext;
+    uint32_t                                    layeredApiCount;
+    VkPhysicalDeviceLayeredApiPropertiesKHR*    pLayeredApis;
+} VkPhysicalDeviceLayeredApiPropertiesListKHR;
+
+typedef struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
+    VkStructureType                sType;
+    void*                          pNext;
+    VkPhysicalDeviceProperties2    properties;
+} VkPhysicalDeviceLayeredApiVulkanPropertiesKHR;
+
+
+
 // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_debug_report 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
@@ -11884,13 +12928,13 @@ typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
 
 // VK_EXT_swapchain_colorspace is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_swapchain_colorspace 1
-#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4
+#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 5
 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
 
 
 // VK_EXT_hdr_metadata is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_hdr_metadata 1
-#define VK_EXT_HDR_METADATA_SPEC_VERSION  2
+#define VK_EXT_HDR_METADATA_SPEC_VERSION  3
 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
 typedef struct VkXYColorEXT {
     float    x;
@@ -13079,33 +14123,23 @@ typedef struct VkPipelineCompilerControlCreateInfoAMD {
 #define VK_EXT_calibrated_timestamps 1
 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2
 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
+typedef VkTimeDomainKHR VkTimeDomainEXT;
 
-typedef enum VkTimeDomainEXT {
-    VK_TIME_DOMAIN_DEVICE_EXT = 0,
-    VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,
-    VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,
-    VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,
-    VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkTimeDomainEXT;
-typedef struct VkCalibratedTimestampInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkTimeDomainEXT    timeDomain;
-} VkCalibratedTimestampInfoEXT;
+typedef VkCalibratedTimestampInfoKHR VkCalibratedTimestampInfoEXT;
 
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
-typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains);
+typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
 
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
     VkPhysicalDevice                            physicalDevice,
     uint32_t*                                   pTimeDomainCount,
-    VkTimeDomainEXT*                            pTimeDomains);
+    VkTimeDomainKHR*                            pTimeDomains);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(
     VkDevice                                    device,
     uint32_t                                    timestampCount,
-    const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
+    const VkCalibratedTimestampInfoKHR*         pTimestampInfos,
     uint64_t*                                   pTimestamps,
     uint64_t*                                   pMaxDeviation);
 #endif
@@ -13165,24 +14199,11 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
     uint32_t           maxVertexAttribDivisor;
 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
 
-typedef struct VkVertexInputBindingDivisorDescriptionEXT {
-    uint32_t    binding;
-    uint32_t    divisor;
-} VkVertexInputBindingDivisorDescriptionEXT;
+typedef VkVertexInputBindingDivisorDescriptionKHR VkVertexInputBindingDivisorDescriptionEXT;
 
-typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
-    VkStructureType                                     sType;
-    const void*                                         pNext;
-    uint32_t                                            vertexBindingDivisorCount;
-    const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
-} VkPipelineVertexInputDivisorStateCreateInfoEXT;
+typedef VkPipelineVertexInputDivisorStateCreateInfoKHR VkPipelineVertexInputDivisorStateCreateInfoEXT;
 
-typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           vertexAttributeInstanceRateDivisor;
-    VkBool32           vertexAttributeInstanceRateZeroDivisor;
-} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
+typedef VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
 
 
 
@@ -13974,39 +14995,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(
 #define VK_EXT_line_rasterization 1
 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
+typedef VkLineRasterizationModeKHR VkLineRasterizationModeEXT;
 
-typedef enum VkLineRasterizationModeEXT {
-    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,
-    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,
-    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,
-    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,
-    VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkLineRasterizationModeEXT;
-typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           rectangularLines;
-    VkBool32           bresenhamLines;
-    VkBool32           smoothLines;
-    VkBool32           stippledRectangularLines;
-    VkBool32           stippledBresenhamLines;
-    VkBool32           stippledSmoothLines;
-} VkPhysicalDeviceLineRasterizationFeaturesEXT;
+typedef VkPhysicalDeviceLineRasterizationFeaturesKHR VkPhysicalDeviceLineRasterizationFeaturesEXT;
 
-typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           lineSubPixelPrecisionBits;
-} VkPhysicalDeviceLineRasterizationPropertiesEXT;
+typedef VkPhysicalDeviceLineRasterizationPropertiesKHR VkPhysicalDeviceLineRasterizationPropertiesEXT;
 
-typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkLineRasterizationModeEXT    lineRasterizationMode;
-    VkBool32                      stippledLineEnable;
-    uint32_t                      lineStippleFactor;
-    uint16_t                      lineStipplePattern;
-} VkPipelineRasterizationLineStateCreateInfoEXT;
+typedef VkPipelineRasterizationLineStateCreateInfoKHR VkPipelineRasterizationLineStateCreateInfoEXT;
 
 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
 
@@ -14062,11 +15057,7 @@ VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(
 #define VK_EXT_index_type_uint8 1
 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
-typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           indexTypeUint8;
-} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
+typedef VkPhysicalDeviceIndexTypeUint8FeaturesKHR VkPhysicalDeviceIndexTypeUint8FeaturesEXT;
 
 
 
@@ -14294,6 +15285,32 @@ VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(
 #endif
 
 
+// VK_EXT_map_memory_placed is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_map_memory_placed 1
+#define VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION 1
+#define VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME "VK_EXT_map_memory_placed"
+typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           memoryMapPlaced;
+    VkBool32           memoryMapRangePlaced;
+    VkBool32           memoryUnmapReserve;
+} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT;
+
+typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       minPlacedMemoryMapAlignment;
+} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT;
+
+typedef struct VkMemoryMapPlacedInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    void*              pPlacedAddress;
+} VkMemoryMapPlacedInfoEXT;
+
+
+
 // VK_EXT_shader_atomic_float2 is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_shader_atomic_float2 1
 #define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1
@@ -14656,7 +15673,7 @@ typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBuff
 
 // VK_QCOM_render_pass_transform is a preprocessor guard. Do not pass it to API calls.
 #define VK_QCOM_render_pass_transform 1
-#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 3
+#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 4
 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform"
 typedef struct VkRenderPassTransformBeginInfoQCOM {
     VkStructureType                  sType;
@@ -15496,7 +16513,7 @@ typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
 
 // VK_QCOM_rotated_copy_commands is a preprocessor guard. Do not pass it to API calls.
 #define VK_QCOM_rotated_copy_commands 1
-#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1
+#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 2
 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands"
 typedef struct VkCopyCommandTransformInfoQCOM {
     VkStructureType                  sType;
@@ -16611,10 +17628,10 @@ typedef struct VkPhysicalDeviceShaderCorePropertiesARM {
 #define VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME "VK_ARM_scheduling_controls"
 typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM;
 
-typedef enum VkPhysicalDeviceSchedulingControlsFlagBitsARM {
-    VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001,
-    VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF
-} VkPhysicalDeviceSchedulingControlsFlagBitsARM;
+// Flag bits for VkPhysicalDeviceSchedulingControlsFlagBitsARM
+typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM;
+static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001ULL;
+
 typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM {
     VkStructureType    sType;
     void*              pNext;
@@ -16743,10 +17760,10 @@ typedef struct VkRenderPassStripeInfoARM {
 } VkRenderPassStripeInfoARM;
 
 typedef struct VkRenderPassStripeBeginInfoARM {
-    VkStructureType               sType;
-    const void*                   pNext;
-    uint32_t                      stripeInfoCount;
-    VkRenderPassStripeInfoARM*    pStripeInfos;
+    VkStructureType                     sType;
+    const void*                         pNext;
+    uint32_t                            stripeInfoCount;
+    const VkRenderPassStripeInfoARM*    pStripeInfos;
 } VkRenderPassStripeBeginInfoARM;
 
 typedef struct VkRenderPassStripeSubmitInfoARM {
@@ -16760,7 +17777,7 @@ typedef struct VkRenderPassStripeSubmitInfoARM {
 
 // VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
 #define VK_QCOM_fragment_density_map_offset 1
-#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1
+#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 2
 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"
 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
     VkStructureType    sType;
@@ -17091,7 +18108,6 @@ typedef struct VkColorBlendAdvancedEXT {
     VkBool32             clampResults;
 } VkColorBlendAdvancedEXT;
 
-typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable);
 typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode);
 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits  rasterizationSamples);
@@ -17102,6 +18118,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBu
 typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables);
 typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations);
 typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks);
+typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream);
 typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode);
 typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize);
@@ -17124,10 +18141,6 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkComma
 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode);
 
 #ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(
-    VkCommandBuffer                             commandBuffer,
-    VkTessellationDomainOrigin                  domainOrigin);
-
 VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    depthClampEnable);
@@ -17175,6 +18188,10 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(
     uint32_t                                    attachmentCount,
     const VkColorComponentFlags*                pColorWriteMasks);
 
+VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkTessellationDomainOrigin                  domainOrigin);
+
 VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    rasterizationStream);
@@ -17571,7 +18588,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(
 
 // VK_EXT_legacy_dithering is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_legacy_dithering 1
-#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 1
+#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 2
 #define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering"
 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
     VkStructureType    sType;
@@ -17796,6 +18813,24 @@ typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
 #define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type"
 
 
+// VK_EXT_legacy_vertex_attributes is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_legacy_vertex_attributes 1
+#define VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION 1
+#define VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME "VK_EXT_legacy_vertex_attributes"
+typedef struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           legacyVertexAttributes;
+} VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT;
+
+typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           nativeUnalignedPerformance;
+} VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT;
+
+
+
 // VK_EXT_layer_settings is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_layer_settings 1
 #define VK_EXT_LAYER_SETTINGS_SPEC_VERSION 2
@@ -18024,6 +19059,19 @@ typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
 
 
 
+// VK_NV_per_stage_descriptor_set is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_per_stage_descriptor_set 1
+#define VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION 1
+#define VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME "VK_NV_per_stage_descriptor_set"
+typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           perStageDescriptorSet;
+    VkBool32           dynamicPipelineLayout;
+} VkPhysicalDevicePerStageDescriptorSetFeaturesNV;
+
+
+
 // VK_QCOM_image_processing2 is a preprocessor guard. Do not pass it to API calls.
 #define VK_QCOM_image_processing2 1
 #define VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION 1
@@ -18167,6 +19215,78 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
 
 
 
+// VK_NV_raw_access_chains is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_raw_access_chains 1
+#define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1
+#define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains"
+typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderRawAccessChains;
+} VkPhysicalDeviceRawAccessChainsFeaturesNV;
+
+
+
+// VK_NV_shader_atomic_float16_vector is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_shader_atomic_float16_vector 1
+#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1
+#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME "VK_NV_shader_atomic_float16_vector"
+typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderFloat16VectorAtomics;
+} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
+
+
+
+// VK_EXT_shader_replicated_composites is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_shader_replicated_composites 1
+#define VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION 1
+#define VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME "VK_EXT_shader_replicated_composites"
+typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderReplicatedComposites;
+} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
+
+
+
+// VK_NV_ray_tracing_validation is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_ray_tracing_validation 1
+#define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1
+#define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation"
+typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           rayTracingValidation;
+} VkPhysicalDeviceRayTracingValidationFeaturesNV;
+
+
+
+// VK_MESA_image_alignment_control is a preprocessor guard. Do not pass it to API calls.
+#define VK_MESA_image_alignment_control 1
+#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1
+#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control"
+typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           imageAlignmentControl;
+} VkPhysicalDeviceImageAlignmentControlFeaturesMESA;
+
+typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           supportedImageAlignmentMask;
+} VkPhysicalDeviceImageAlignmentControlPropertiesMESA;
+
+typedef struct VkImageAlignmentControlCreateInfoMESA {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           maximumRequestedAlignment;
+} VkImageAlignmentControlCreateInfoMESA;
+
+
+
 // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_acceleration_structure 1
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
diff --git a/WickedEngine/Utility/vulkan/vulkan_directfb.h b/WickedEngine/Utility/vulkan/vulkan_directfb.h
index 1f11a0827..f06f80b70 100644
--- a/WickedEngine/Utility/vulkan/vulkan_directfb.h
+++ b/WickedEngine/Utility/vulkan/vulkan_directfb.h
@@ -2,7 +2,7 @@
 #define VULKAN_DIRECTFB_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_fuchsia.h b/WickedEngine/Utility/vulkan/vulkan_fuchsia.h
index 76e156483..f60907d10 100644
--- a/WickedEngine/Utility/vulkan/vulkan_fuchsia.h
+++ b/WickedEngine/Utility/vulkan/vulkan_fuchsia.h
@@ -2,7 +2,7 @@
 #define VULKAN_FUCHSIA_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_ggp.h b/WickedEngine/Utility/vulkan/vulkan_ggp.h
index 9783aa3b3..0a8863a14 100644
--- a/WickedEngine/Utility/vulkan/vulkan_ggp.h
+++ b/WickedEngine/Utility/vulkan/vulkan_ggp.h
@@ -2,7 +2,7 @@
 #define VULKAN_GGP_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_ios.h b/WickedEngine/Utility/vulkan/vulkan_ios.h
index 211429ff4..22ed2c039 100644
--- a/WickedEngine/Utility/vulkan/vulkan_ios.h
+++ b/WickedEngine/Utility/vulkan/vulkan_ios.h
@@ -2,7 +2,7 @@
 #define VULKAN_IOS_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_macos.h b/WickedEngine/Utility/vulkan/vulkan_macos.h
index c6509cc8c..a7f5613a0 100644
--- a/WickedEngine/Utility/vulkan/vulkan_macos.h
+++ b/WickedEngine/Utility/vulkan/vulkan_macos.h
@@ -2,7 +2,7 @@
 #define VULKAN_MACOS_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_metal.h b/WickedEngine/Utility/vulkan/vulkan_metal.h
index 94563a003..89a557490 100644
--- a/WickedEngine/Utility/vulkan/vulkan_metal.h
+++ b/WickedEngine/Utility/vulkan/vulkan_metal.h
@@ -2,7 +2,7 @@
 #define VULKAN_METAL_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -52,28 +52,28 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
 #define VK_EXT_metal_objects 1
 #ifdef __OBJC__
 @protocol MTLDevice;
-typedef id<MTLDevice> MTLDevice_id;
+typedef __unsafe_unretained id<MTLDevice> MTLDevice_id;
 #else
 typedef void* MTLDevice_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLCommandQueue;
-typedef id<MTLCommandQueue> MTLCommandQueue_id;
+typedef __unsafe_unretained id<MTLCommandQueue> MTLCommandQueue_id;
 #else
 typedef void* MTLCommandQueue_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLBuffer;
-typedef id<MTLBuffer> MTLBuffer_id;
+typedef __unsafe_unretained id<MTLBuffer> MTLBuffer_id;
 #else
 typedef void* MTLBuffer_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLTexture;
-typedef id<MTLTexture> MTLTexture_id;
+typedef __unsafe_unretained id<MTLTexture> MTLTexture_id;
 #else
 typedef void* MTLTexture_id;
 #endif
@@ -81,12 +81,12 @@ typedef void* MTLTexture_id;
 typedef struct __IOSurface* IOSurfaceRef;
 #ifdef __OBJC__
 @protocol MTLSharedEvent;
-typedef id<MTLSharedEvent> MTLSharedEvent_id;
+typedef __unsafe_unretained id<MTLSharedEvent> MTLSharedEvent_id;
 #else
 typedef void* MTLSharedEvent_id;
 #endif
 
-#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1
+#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 2
 #define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects"
 
 typedef enum VkExportMetalObjectTypeFlagBitsEXT {
diff --git a/WickedEngine/Utility/vulkan/vulkan_screen.h b/WickedEngine/Utility/vulkan/vulkan_screen.h
index 981738f73..7e84d4d96 100644
--- a/WickedEngine/Utility/vulkan/vulkan_screen.h
+++ b/WickedEngine/Utility/vulkan/vulkan_screen.h
@@ -2,7 +2,7 @@
 #define VULKAN_SCREEN_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_vi.h b/WickedEngine/Utility/vulkan/vulkan_vi.h
index c9227e822..c145f4a80 100644
--- a/WickedEngine/Utility/vulkan/vulkan_vi.h
+++ b/WickedEngine/Utility/vulkan/vulkan_vi.h
@@ -2,7 +2,7 @@
 #define VULKAN_VI_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_wayland.h b/WickedEngine/Utility/vulkan/vulkan_wayland.h
index c93b21787..ec706a114 100644
--- a/WickedEngine/Utility/vulkan/vulkan_wayland.h
+++ b/WickedEngine/Utility/vulkan/vulkan_wayland.h
@@ -2,7 +2,7 @@
 #define VULKAN_WAYLAND_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_win32.h b/WickedEngine/Utility/vulkan/vulkan_win32.h
index fae3b8532..d7a0b2bab 100644
--- a/WickedEngine/Utility/vulkan/vulkan_win32.h
+++ b/WickedEngine/Utility/vulkan/vulkan_win32.h
@@ -2,7 +2,7 @@
 #define VULKAN_WIN32_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_xcb.h b/WickedEngine/Utility/vulkan/vulkan_xcb.h
index de7405524..cdf6b5269 100644
--- a/WickedEngine/Utility/vulkan/vulkan_xcb.h
+++ b/WickedEngine/Utility/vulkan/vulkan_xcb.h
@@ -2,7 +2,7 @@
 #define VULKAN_XCB_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_xlib.h b/WickedEngine/Utility/vulkan/vulkan_xlib.h
index 1aa632f2e..b3c3e27d7 100644
--- a/WickedEngine/Utility/vulkan/vulkan_xlib.h
+++ b/WickedEngine/Utility/vulkan/vulkan_xlib.h
@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
diff --git a/WickedEngine/Utility/vulkan/vulkan_xlib_xrandr.h b/WickedEngine/Utility/vulkan/vulkan_xlib_xrandr.h
index e164ffc91..8e99190b4 100644
--- a/WickedEngine/Utility/vulkan/vulkan_xlib_xrandr.h
+++ b/WickedEngine/Utility/vulkan/vulkan_xlib_xrandr.h
@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_XRANDR_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2024 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */