updated vulkan to make use of cm2

include/vulkan/glslang/Include/glslang_c_interface.h

@@ -284,7 +284,7 @@ GLSLANG_EXPORT const char* glslang_program_SPIRV_get_messages(glslang_program_t*
 GLSLANG_EXPORT const char* glslang_program_get_info_log(glslang_program_t* program);
 GLSLANG_EXPORT const char* glslang_program_get_info_debug_log(glslang_program_t* program);
 
-GLSLANG_EXPORT glslang_mapper_t* glslang_glsl_mapper_create();
+GLSLANG_EXPORT glslang_mapper_t* glslang_glsl_mapper_create(void);
 GLSLANG_EXPORT void glslang_glsl_mapper_delete(glslang_mapper_t* mapper);
 
 GLSLANG_EXPORT glslang_resolver_t* glslang_glsl_resolver_create(glslang_program_t* program, glslang_stage_t stage);

include/vulkan/glslang/Include/glslang_c_shader_types.h

@@ -118,8 +118,9 @@ typedef enum {
     GLSLANG_TARGET_VULKAN_1_1 = (1 << 22) | (1 << 12),
     GLSLANG_TARGET_VULKAN_1_2 = (1 << 22) | (2 << 12),
     GLSLANG_TARGET_VULKAN_1_3 = (1 << 22) | (3 << 12),
+    GLSLANG_TARGET_VULKAN_1_4 = (1 << 22) | (4 << 12),
     GLSLANG_TARGET_OPENGL_450 = 450,
-    LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 5),
+    LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 6),
 } glslang_target_client_version_t;
 
 /* SH_TARGET_LanguageVersion counterpart */
@@ -176,6 +177,7 @@ typedef enum {
     GLSLANG_MSG_ENHANCED                    = (1 << 15),
     GLSLANG_MSG_ABSOLUTE_PATH               = (1 << 16),
     GLSLANG_MSG_DISPLAY_ERROR_COLUMN        = (1 << 17),
+    GLSLANG_MSG_LINK_TIME_OPTIMIZATION_BIT  = (1 << 18),
     LAST_ELEMENT_MARKER(GLSLANG_MSG_COUNT),
 } glslang_messages_t;
 

include/vulkan/glslang/MachineIndependent/Versions.h

@@ -4,6 +4,7 @@
 // Copyright (C) 2017, 2022-2024 Arm Limited.
 // Copyright (C) 2015-2018 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
+// Modifications Copyright (C) 2024 Valve Corporation.
 //
 // All rights reserved.
 //
@@ -223,6 +224,8 @@ const char* const E_GL_EXT_maximal_reconvergence            = "GL_EXT_maximal_re
 const char* const E_GL_EXT_expect_assume                    = "GL_EXT_expect_assume";
 const char* const E_GL_EXT_control_flow_attributes2         = "GL_EXT_control_flow_attributes2";
 const char* const E_GL_EXT_spec_constant_composites         = "GL_EXT_spec_constant_composites";
+const char* const E_GL_EXT_texture_offset_non_const         = "GL_EXT_texture_offset_non_const";
+const char* const E_GL_EXT_nontemporal_keyword              = "GL_EXT_nontemporal_keyword";
 
 // Arrays of extensions for the above viewportEXTs duplications
 
@@ -282,6 +285,10 @@ const char* const E_GL_NV_shader_invocation_reorder             = "GL_NV_shader_
 const char* const E_GL_EXT_ray_tracing_position_fetch           = "GL_EXT_ray_tracing_position_fetch";
 const char* const E_GL_NV_displacement_micromap                 = "GL_NV_displacement_micromap";
 const char* const E_GL_NV_shader_atomic_fp16_vector             = "GL_NV_shader_atomic_fp16_vector";
+const char* const E_GL_NV_cooperative_matrix2                   = "GL_NV_cooperative_matrix2";
+const char* const E_GL_NV_cooperative_vector                    = "GL_NV_cooperative_vector";
+const char* const E_GL_NV_cluster_acceleration_structure        = "GL_NV_cluster_acceleration_structure";
+const char* const E_GL_NV_linear_swept_spheres                  = "GL_NV_linear_swept_spheres";
 
 // ARM
 const char* const E_GL_ARM_shader_core_builtins                 = "GL_ARM_shader_core_builtins";
@@ -347,6 +354,8 @@ const char* const E_GL_EXT_shader_tile_image = "GL_EXT_shader_tile_image";
 
 const char* const E_GL_EXT_texture_shadow_lod = "GL_EXT_texture_shadow_lod";
 
+const char* const E_GL_EXT_integer_dot_product                    = "GL_EXT_integer_dot_product";
+
 // Arrays of extensions for the above AEP duplications
 
 const char* const AEP_geometry_shader[] = { E_GL_EXT_geometry_shader, E_GL_OES_geometry_shader };

include/vulkan/glslang/Public/ShaderLang.h

@@ -156,8 +156,9 @@ typedef enum {
     EShTargetVulkan_1_1 = (1 << 22) | (1 << 12),      // Vulkan 1.1
     EShTargetVulkan_1_2 = (1 << 22) | (2 << 12),      // Vulkan 1.2
     EShTargetVulkan_1_3 = (1 << 22) | (3 << 12),      // Vulkan 1.3
+    EShTargetVulkan_1_4 = (1 << 22) | (4 << 12),      // Vulkan 1.4
     EShTargetOpenGL_450 = 450,                        // OpenGL
-    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 5),
+    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 6),
 } EShTargetClientVersion;
 
 typedef EShTargetClientVersion EshTargetClientVersion;
@@ -271,6 +272,7 @@ enum EShMessages : unsigned {
     EShMsgEnhanced             = (1 << 15), // enhanced message readability
     EShMsgAbsolutePath         = (1 << 16), // Output Absolute path for messages
     EShMsgDisplayErrorColumn   = (1 << 17), // Display error message column aswell as line
+    EShMsgLinkTimeOptimization = (1 << 18), // perform cross-stage optimizations during linking
     LAST_ELEMENT_MARKER(EShMsgCount),
 };
 

include/vulkan/glslang/build_info.h

@@ -35,7 +35,7 @@
 #define GLSLANG_BUILD_INFO
 
 #define GLSLANG_VERSION_MAJOR 15
-#define GLSLANG_VERSION_MINOR 0
+#define GLSLANG_VERSION_MINOR 2
 #define GLSLANG_VERSION_PATCH 0
 #define GLSLANG_VERSION_FLAVOR ""
 

include/vulkan/shaderc/env.h

@@ -41,6 +41,7 @@ typedef enum {
   shaderc_env_version_vulkan_1_1 = ((1u << 22) | (1 << 12)),
   shaderc_env_version_vulkan_1_2 = ((1u << 22) | (2 << 12)),
   shaderc_env_version_vulkan_1_3 = ((1u << 22) | (3 << 12)),
+  shaderc_env_version_vulkan_1_4 = ((1u << 22) | (4 << 12)),
   // For OpenGL, use the number from #version in shaders.
   // TODO(dneto): Currently no difference between OpenGL 4.5 and 4.6.
   // See glslang/Standalone/Standalone.cpp

include/vulkan/slang/slang-com-helper.h

@@ -5,33 +5,87 @@
  */
 
 #include "slang.h"
+
 #include <atomic>
 
 /* !!!!!!!!!!!!!!!!!!!!! Macros to help checking SlangResult !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
 
-/*! Set SLANG_HANDLE_RESULT_FAIL(x) to code to be executed whenever an error occurs, and is detected by one of the macros */
+/*! Set SLANG_HANDLE_RESULT_FAIL(x) to code to be executed whenever an error occurs, and is detected
+ * by one of the macros */
 #ifndef SLANG_HANDLE_RESULT_FAIL
     #define SLANG_HANDLE_RESULT_FAIL(x)
 #endif
 
-//! Helper macro, that makes it easy to add result checking to calls in functions/methods that themselves return Result. 
+//! Helper macro, that makes it easy to add result checking to calls in functions/methods that
-#define SLANG_RETURN_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return _res; } }
+//! themselves return Result.
-//! Helper macro that can be used to test the return value from a call, and will return in a void method/function
+#define SLANG_RETURN_ON_FAIL(x)             \
-#define SLANG_RETURN_VOID_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return; } }
+    {                                       \
+        SlangResult _res = (x);             \
+        if (SLANG_FAILED(_res))             \
+        {                                   \
+            SLANG_HANDLE_RESULT_FAIL(_res); \
+            return _res;                    \
+        }                                   \
+    }
+//! Helper macro that can be used to test the return value from a call, and will return in a void
+//! method/function
+#define SLANG_RETURN_VOID_ON_FAIL(x)        \
+    {                                       \
+        SlangResult _res = (x);             \
+        if (SLANG_FAILED(_res))             \
+        {                                   \
+            SLANG_HANDLE_RESULT_FAIL(_res); \
+            return;                         \
+        }                                   \
+    }
 //! Helper macro that will return false on failure.
-#define SLANG_RETURN_FALSE_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return false; } }
+#define SLANG_RETURN_FALSE_ON_FAIL(x)       \
+    {                                       \
+        SlangResult _res = (x);             \
+        if (SLANG_FAILED(_res))             \
+        {                                   \
+            SLANG_HANDLE_RESULT_FAIL(_res); \
+            return false;                   \
+        }                                   \
+    }
 //! Helper macro that will return nullptr on failure.
-#define SLANG_RETURN_NULL_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return nullptr; } }
+#define SLANG_RETURN_NULL_ON_FAIL(x)        \
+    {                                       \
+        SlangResult _res = (x);             \
+        if (SLANG_FAILED(_res))             \
+        {                                   \
+            SLANG_HANDLE_RESULT_FAIL(_res); \
+            return nullptr;                 \
+        }                                   \
+    }
 
-//! Helper macro that will assert if the return code from a call is failure, also returns the failure.
+//! Helper macro that will assert if the return code from a call is failure, also returns the
-#define SLANG_ASSERT_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { assert(false); return _res; } }
+//! failure.
+#define SLANG_ASSERT_ON_FAIL(x) \
+    {                           \
+        SlangResult _res = (x); \
+        if (SLANG_FAILED(_res)) \
+        {                       \
+            assert(false);      \
+            return _res;        \
+        }                       \
+    }
 //! Helper macro that will assert if the result from a call is a failure, also returns.
-#define SLANG_ASSERT_VOID_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { assert(false); return; } }
+#define SLANG_ASSERT_VOID_ON_FAIL(x) \
+    {                                \
+        SlangResult _res = (x);      \
+        if (SLANG_FAILED(_res))      \
+        {                            \
+            assert(false);           \
+            return;                  \
+        }                            \
+    }
 
 /* !!!!!!!!!!!!!!!!!!!!!!! C++ helpers !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
 
 #if defined(__cplusplus)
-namespace Slang {
+namespace Slang
+{
 
 // Alias SlangResult to Slang::Result
 typedef SlangResult Result;
@@ -66,12 +120,14 @@ SLANG_FORCE_INLINE bool operator!=(const Slang::Guid& a, const Slang::Guid& b)
 
     /* !!!!!!!! Macros to simplify implementing COM interfaces !!!!!!!!!!!!!!!!!!!!!!!!!!!! */
 
-/* Assumes underlying implementation has a member m_refCount that is initialized to 0 and can have ++ and -- operate on it. 
+    /* Assumes underlying implementation has a member m_refCount that is initialized to 0 and can
-For SLANG_IUNKNOWN_QUERY_INTERFACE to work - must have a method 'getInterface' that returns valid pointers for the Guid, or nullptr 
+    have ++ and -- operate on it. For SLANG_IUNKNOWN_QUERY_INTERFACE to work - must have a method
-if not found. */
+    'getInterface' that returns valid pointers for the Guid, or nullptr if not found. */
 
     #define SLANG_IUNKNOWN_QUERY_INTERFACE                     \
-SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) SLANG_OVERRIDE \
+        SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface( \
+            SlangUUID const& uuid,                             \
+            void** outObject) SLANG_OVERRIDE                   \
         {                                                      \
             ISlangUnknown* intf = getInterface(uuid);          \
             if (intf)                                          \
@@ -109,7 +165,9 @@ SLANG_NO_THROW uint32_t SLANG_MCALL release() \
     // ------------------------ RefObject IUnknown -----------------------------
 
     #define SLANG_REF_OBJECT_IUNKNOWN_QUERY_INTERFACE          \
-SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) SLANG_OVERRIDE \
+        SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface( \
+            SlangUUID const& uuid,                             \
+            void** outObject) SLANG_OVERRIDE                   \
         {                                                      \
             void* intf = getInterface(uuid);                   \
             if (intf)                                          \
@@ -121,8 +179,16 @@ SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, voi
             return SLANG_E_NO_INTERFACE;                       \
         }
 
-#define SLANG_REF_OBJECT_IUNKNOWN_ADD_REF SLANG_NO_THROW uint32_t SLANG_MCALL addRef() SLANG_OVERRIDE { return (uint32_t)addReference(); }
+    #define SLANG_REF_OBJECT_IUNKNOWN_ADD_REF                       \
-#define SLANG_REF_OBJECT_IUNKNOWN_RELEASE SLANG_NO_THROW uint32_t SLANG_MCALL release() SLANG_OVERRIDE { return (uint32_t)releaseReference(); }
+        SLANG_NO_THROW uint32_t SLANG_MCALL addRef() SLANG_OVERRIDE \
+        {                                                           \
+            return (uint32_t)addReference();                        \
+        }
+    #define SLANG_REF_OBJECT_IUNKNOWN_RELEASE                        \
+        SLANG_NO_THROW uint32_t SLANG_MCALL release() SLANG_OVERRIDE \
+        {                                                            \
+            return (uint32_t)releaseReference();                     \
+        }
 
     #define SLANG_REF_OBJECT_IUNKNOWN_ALL         \
         SLANG_REF_OBJECT_IUNKNOWN_QUERY_INTERFACE \

include/vulkan/slang/slang-com-ptr.h

@@ -6,20 +6,21 @@
 #include <assert.h>
 #include <cstddef>
 
-namespace Slang {
+namespace Slang
+{
 
 /*! \brief ComPtr is a simple smart pointer that manages types which implement COM based interfaces.
-\details A class that implements a COM, must derive from the IUnknown interface or a type that matches
+\details A class that implements a COM, must derive from the IUnknown interface or a type that
-it's layout exactly (such as ISlangUnknown). Trying to use this template with a class that doesn't follow
+matches it's layout exactly (such as ISlangUnknown). Trying to use this template with a class that
-these rules, will lead to undefined behavior.
+doesn't follow these rules, will lead to undefined behavior. This is a 'strong' pointer type, and
-This is a 'strong' pointer type, and will AddRef when a non null pointer is set and Release when the pointer
+will AddRef when a non null pointer is set and Release when the pointer leaves scope. Using 'detach'
-leaves scope.
+allows a pointer to be removed from the management of the ComPtr. To set the smart pointer to null,
-Using 'detach' allows a pointer to be removed from the management of the ComPtr.
+there is the method setNull, or alternatively just assign SLANG_NULL/nullptr.
-To set the smart pointer to null, there is the method setNull, or alternatively just assign SLANG_NULL/nullptr.
 
-One edge case using the template is that sometimes you want access as a pointer to a pointer. Sometimes this
+One edge case using the template is that sometimes you want access as a pointer to a pointer.
-is to write into the smart pointer, other times to pass as an array. To handle these different behaviors
+Sometimes this is to write into the smart pointer, other times to pass as an array. To handle these
-there are the methods readRef and writeRef, which are used instead of the & (ref) operator. For example
+different behaviors there are the methods readRef and writeRef, which are used instead of the &
+(ref) operator. For example
 
 \code
 Void doSomething(ID3D12Resource** resources, IndexT numResources);
@@ -54,27 +55,63 @@ public:
 
     /// Constructors
     /// Default Ctor. Sets to nullptr
-	SLANG_FORCE_INLINE ComPtr() :m_ptr(nullptr) {}
+    SLANG_FORCE_INLINE ComPtr()
-    SLANG_FORCE_INLINE ComPtr(std::nullptr_t) : m_ptr(nullptr) {}
+        : m_ptr(nullptr)
+    {
+    }
+    SLANG_FORCE_INLINE ComPtr(std::nullptr_t)
+        : m_ptr(nullptr)
+    {
+    }
     /// Sets, and ref counts.
-	SLANG_FORCE_INLINE explicit ComPtr(T* ptr) :m_ptr(ptr) { if (ptr) ((Ptr)ptr)->addRef(); }
+    SLANG_FORCE_INLINE explicit ComPtr(T* ptr)
+        : m_ptr(ptr)
+    {
+        if (ptr)
+            ((Ptr)ptr)->addRef();
+    }
     /// The copy ctor
-	SLANG_FORCE_INLINE ComPtr(const ThisType& rhs) : m_ptr(rhs.m_ptr) { if (m_ptr) ((Ptr)m_ptr)->addRef(); }
+    SLANG_FORCE_INLINE ComPtr(const ThisType& rhs)
+        : m_ptr(rhs.m_ptr)
+    {
+        if (m_ptr)
+            ((Ptr)m_ptr)->addRef();
+    }
 
     /// Ctor without adding to ref count.
-    SLANG_FORCE_INLINE explicit ComPtr(InitAttach, T* ptr) :m_ptr(ptr) { }
+    SLANG_FORCE_INLINE explicit ComPtr(InitAttach, T* ptr)
+        : m_ptr(ptr)
+    {
+    }
     /// Ctor without adding to ref count
-    SLANG_FORCE_INLINE ComPtr(InitAttach, const ThisType& rhs) : m_ptr(rhs.m_ptr) { }
+    SLANG_FORCE_INLINE ComPtr(InitAttach, const ThisType& rhs)
+        : m_ptr(rhs.m_ptr)
+    {
+    }
 
 #ifdef SLANG_HAS_MOVE_SEMANTICS
     /// Move Ctor
-	SLANG_FORCE_INLINE ComPtr(ThisType&& rhs) : m_ptr(rhs.m_ptr) { rhs.m_ptr = nullptr; }
+    SLANG_FORCE_INLINE ComPtr(ThisType&& rhs)
+        : m_ptr(rhs.m_ptr)
+    {
+        rhs.m_ptr = nullptr;
+    }
     /// Move assign
-	SLANG_FORCE_INLINE ComPtr& operator=(ThisType&& rhs) { T* swap = m_ptr; m_ptr = rhs.m_ptr; rhs.m_ptr = swap; return *this; }
+    SLANG_FORCE_INLINE ComPtr& operator=(ThisType&& rhs)
+    {
+        T* swap = m_ptr;
+        m_ptr = rhs.m_ptr;
+        rhs.m_ptr = swap;
+        return *this;
+    }
 #endif
 
     /// Destructor releases the pointer, assuming it is set
-	SLANG_FORCE_INLINE ~ComPtr() { if (m_ptr) ((Ptr)m_ptr)->release(); }
+    SLANG_FORCE_INLINE ~ComPtr()
+    {
+        if (m_ptr)
+            ((Ptr)m_ptr)->release();
+    }
 
     // !!! Operators !!!
 
@@ -96,12 +133,21 @@ public:
     SLANG_FORCE_INLINE void setNull();
 
     /// Detach
-	SLANG_FORCE_INLINE T* detach() { T* ptr = m_ptr; m_ptr = nullptr; return ptr; }
+    SLANG_FORCE_INLINE T* detach()
+    {
+        T* ptr = m_ptr;
+        m_ptr = nullptr;
+        return ptr;
+    }
     /// Set to a pointer without changing the ref count
     SLANG_FORCE_INLINE void attach(T* in) { m_ptr = in; }
 
     /// Get ready for writing (nulls contents)
-	SLANG_FORCE_INLINE T** writeRef() { setNull(); return &m_ptr; }
+    SLANG_FORCE_INLINE T** writeRef()
+    {
+        setNull();
+        return &m_ptr;
+    }
     /// Get for read access
     SLANG_FORCE_INLINE T* const* readRef() const { return &m_ptr; }
 
@@ -132,8 +178,10 @@ void ComPtr<T>::setNull()
 template<typename T>
 const ComPtr<T>& ComPtr<T>::operator=(const ThisType& rhs)
 {
-	if (rhs.m_ptr) ((Ptr)rhs.m_ptr)->addRef();
+    if (rhs.m_ptr)
-	if (m_ptr) ((Ptr)m_ptr)->release();
+        ((Ptr)rhs.m_ptr)->addRef();
+    if (m_ptr)
+        ((Ptr)m_ptr)->release();
     m_ptr = rhs.m_ptr;
     return *this;
 }
@@ -141,8 +189,10 @@ const ComPtr<T>& ComPtr<T>::operator=(const ThisType& rhs)
 template<typename T>
 T* ComPtr<T>::operator=(T* ptr)
 {
-	if (ptr) ((Ptr)ptr)->addRef();
+    if (ptr)
-	if (m_ptr) ((Ptr)m_ptr)->release();
+        ((Ptr)ptr)->addRef();
+    if (m_ptr)
+        ((Ptr)m_ptr)->release();
     m_ptr = ptr;
     return m_ptr;
 }

include/vulkan/slang/slang-cpp-host-prelude.h

@@ -1,8 +1,8 @@
 #ifndef SLANG_CPP_HOST_PRELUDE_H
 #define SLANG_CPP_HOST_PRELUDE_H
 
-#include <cstdio>
 #include <cmath>
+#include <cstdio>
 #include <cstring>
 
 #define SLANG_COM_PTR_ENABLE_REF_OPERATOR 1
@@ -23,21 +23,24 @@
 #endif
 
 #include <assert.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-#   include <stdint.h>
 #endif // SLANG_LLVM
 
 #if defined(_MSC_VER)
 #define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)
 #else
 #define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default")))
-//#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default")))
+// #   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport))
+// __attribute__((__visibility__("default")))
 #endif
 
 #ifdef __cplusplus
 #define SLANG_PRELUDE_EXTERN_C extern "C"
-#   define SLANG_PRELUDE_EXTERN_C_START extern "C" {
+#define SLANG_PRELUDE_EXTERN_C_START \
+    extern "C"                       \
+    {
 #define SLANG_PRELUDE_EXTERN_C_END }
 #else
 #define SLANG_PRELUDE_EXTERN_C

include/vulkan/slang/slang-cpp-prelude.h

@@ -17,21 +17,24 @@
 #endif
 
 #include <assert.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-#   include <stdint.h>
 #endif // SLANG_LLVM
 
 #if defined(_MSC_VER)
 #define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)
 #else
 #define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default")))
-//#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default")))
+// #   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport))
+// __attribute__((__visibility__("default")))
 #endif
 
 #ifdef __cplusplus
 #define SLANG_PRELUDE_EXTERN_C extern "C"
-#   define SLANG_PRELUDE_EXTERN_C_START extern "C" {
+#define SLANG_PRELUDE_EXTERN_C_START \
+    extern "C"                       \
+    {
 #define SLANG_PRELUDE_EXTERN_C_END }
 #else
 #define SLANG_PRELUDE_EXTERN_C
@@ -142,7 +145,8 @@ Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSyst
 #define SLANG_IOS 1
 #endif
 #elif defined(__APPLE__)
-// On `slang-llvm` we can't inclue "TargetConditionals.h" in general, so for now assume its OSX.
+// On `slang-llvm` we can't inclue "TargetConditionals.h" in general, so for now assume its
+// OSX.
 #define SLANG_OSX 1
 #elif defined(__CELLOS_LV2__)
 #define SLANG_PS3 1
@@ -207,7 +211,8 @@ Any platforms not detected by the above logic are now now explicitly zeroed out.
 #define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY)
 #define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID)
 #define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX) /* equivalent to #if __APPLE__ */
-#define SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */
+#define SLANG_UNIX_FAMILY \
+    (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */
 
 // GCC Specific
 #if SLANG_GCC_FAMILY
@@ -285,7 +290,8 @@ typedef int32_t SlangResult;
 
 struct ISlangUnknown
 {
-    virtual SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) = 0;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+    queryInterface(SlangUUID const& uuid, void** outObject) = 0;
     virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() = 0;
     virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() = 0;
 };

include/vulkan/slang/slang-cpp-scalar-intrinsics.h

@@ -2,7 +2,8 @@
 #define SLANG_PRELUDE_SCALAR_INTRINSICS_H
 
 #if !defined(SLANG_LLVM) && SLANG_PROCESSOR_X86_64 && SLANG_VC
-//  If we have visual studio and 64 bit processor, we can assume we have popcnt, and can include x86 intrinsics
+//  If we have visual studio and 64 bit processor, we can assume we have popcnt, and can include
+//  x86 intrinsics
 #include <intrin.h>
 #endif
 
@@ -11,7 +12,8 @@
 #endif
 
 #ifdef SLANG_PRELUDE_NAMESPACE
-namespace SLANG_PRELUDE_NAMESPACE {
+namespace SLANG_PRELUDE_NAMESPACE
+{
 #endif
 
 #ifndef SLANG_PRELUDE_PI
@@ -34,10 +36,30 @@ union Union64
 };
 
 // 32 bit cast conversions
-SLANG_FORCE_INLINE int32_t _bitCastFloatToInt(float f) { Union32 u; u.f = f; return u.i; }
+SLANG_FORCE_INLINE int32_t _bitCastFloatToInt(float f)
-SLANG_FORCE_INLINE float _bitCastIntToFloat(int32_t i) { Union32 u; u.i = i; return u.f; }
+{
-SLANG_FORCE_INLINE uint32_t _bitCastFloatToUInt(float f) { Union32 u; u.f = f; return u.u; }
+    Union32 u;
-SLANG_FORCE_INLINE float _bitCastUIntToFloat(uint32_t ui) { Union32 u; u.u = ui; return u.f; }
+    u.f = f;
+    return u.i;
+}
+SLANG_FORCE_INLINE float _bitCastIntToFloat(int32_t i)
+{
+    Union32 u;
+    u.i = i;
+    return u.f;
+}
+SLANG_FORCE_INLINE uint32_t _bitCastFloatToUInt(float f)
+{
+    Union32 u;
+    u.f = f;
+    return u.u;
+}
+SLANG_FORCE_INLINE float _bitCastUIntToFloat(uint32_t ui)
+{
+    Union32 u;
+    u.u = ui;
+    return u.f;
+}
 
 // ----------------------------- F16 -----------------------------------------
 
@@ -69,8 +91,8 @@ SLANG_FORCE_INLINE uint32_t f32tof16(const float value)
         // semantics are the same. (The signalling bit convention is target specific!).
         // Non signal bit's usage within mantissa for a NAN are also target specific.
 
-        // If the m is 0, it could be because the result is INF, but it could also be because all the 
+        // If the m is 0, it could be because the result is INF, but it could also be because all
-        // bits that made NAN were dropped as we have less mantissa bits in f16. 
+        // the bits that made NAN were dropped as we have less mantissa bits in f16.
 
         // To fix for this we make non zero if m is 0 and the input mantissa was not.
         // This will (typically) produce a signalling NAN.
@@ -117,7 +139,8 @@ SLANG_FORCE_INLINE float f16tof32(const uint32_t value)
     {
         // If the exponent is NAN or INF exponent is 0x1f on input.
         // If that's the case, we just need to set the exponent to 0xff on output
-        // and the mantissa can just stay the same. If its 0 it's INF, else it is NAN and we just copy the bits
+        // and the mantissa can just stay the same. If its 0 it's INF, else it is NAN and we just
+        // copy the bits
         //
         // Else we need to correct the exponent in the normalized case.
         exponent = (exponent == 0x1F) ? 0xff : (exponent + (-15 + 127));
@@ -162,8 +185,14 @@ bool F32_isfinite(float f);
 bool F32_isinf(float f);
 
 // Binary
-SLANG_FORCE_INLINE float F32_min(float a, float b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE float F32_min(float a, float b)
-SLANG_FORCE_INLINE float F32_max(float a, float b) { return a > b ? a : b; }
+{
+    return a < b ? a : b;
+}
+SLANG_FORCE_INLINE float F32_max(float a, float b)
+{
+    return a > b ? a : b;
+}
 float F32_pow(float a, float b);
 float F32_fmod(float a, float b);
 float F32_remainder(float a, float b);
@@ -174,47 +203,140 @@ float F32_frexp(float x, int* e);
 float F32_modf(float x, float* ip);
 
 // Ternary
-SLANG_FORCE_INLINE float F32_fma(float a, float b, float c) { return a * b + c; }
+SLANG_FORCE_INLINE float F32_fma(float a, float b, float c)
+{
+    return a * b + c;
+}
 
 SLANG_PRELUDE_EXTERN_C_END
 
 #else
 
 // Unary
-SLANG_FORCE_INLINE float F32_ceil(float f) { return ::ceilf(f); }
+SLANG_FORCE_INLINE float F32_ceil(float f)
-SLANG_FORCE_INLINE float F32_floor(float f) { return ::floorf(f); }
+{
-SLANG_FORCE_INLINE float F32_round(float f) { return ::roundf(f); }
+    return ::ceilf(f);
-SLANG_FORCE_INLINE float F32_sin(float f) { return ::sinf(f); }
+}
-SLANG_FORCE_INLINE float F32_cos(float f) { return ::cosf(f); }
+SLANG_FORCE_INLINE float F32_floor(float f)
-SLANG_FORCE_INLINE float F32_tan(float f) { return ::tanf(f); }
+{
-SLANG_FORCE_INLINE float F32_asin(float f) { return ::asinf(f); }
+    return ::floorf(f);
-SLANG_FORCE_INLINE float F32_acos(float f) { return ::acosf(f); }
+}
-SLANG_FORCE_INLINE float F32_atan(float f) { return ::atanf(f); }
+SLANG_FORCE_INLINE float F32_round(float f)
-SLANG_FORCE_INLINE float F32_sinh(float f) { return ::sinhf(f); }
+{
-SLANG_FORCE_INLINE float F32_cosh(float f) { return ::coshf(f); }
+    return ::roundf(f);
-SLANG_FORCE_INLINE float F32_tanh(float f) { return ::tanhf(f); }
+}
-SLANG_FORCE_INLINE float F32_log2(float f) { return ::log2f(f); }
+SLANG_FORCE_INLINE float F32_sin(float f)
-SLANG_FORCE_INLINE float F32_log(float f) { return ::logf(f); }
+{
-SLANG_FORCE_INLINE float F32_log10(float f) { return ::log10f(f); }
+    return ::sinf(f);
-SLANG_FORCE_INLINE float F32_exp2(float f) { return ::exp2f(f); }
+}
-SLANG_FORCE_INLINE float F32_exp(float f) { return ::expf(f); }
+SLANG_FORCE_INLINE float F32_cos(float f)
-SLANG_FORCE_INLINE float F32_abs(float f) { return ::fabsf(f); }
+{
-SLANG_FORCE_INLINE float F32_trunc(float f) { return ::truncf(f); }
+    return ::cosf(f);
-SLANG_FORCE_INLINE float F32_sqrt(float f) { return ::sqrtf(f); }
+}
+SLANG_FORCE_INLINE float F32_tan(float f)
+{
+    return ::tanf(f);
+}
+SLANG_FORCE_INLINE float F32_asin(float f)
+{
+    return ::asinf(f);
+}
+SLANG_FORCE_INLINE float F32_acos(float f)
+{
+    return ::acosf(f);
+}
+SLANG_FORCE_INLINE float F32_atan(float f)
+{
+    return ::atanf(f);
+}
+SLANG_FORCE_INLINE float F32_sinh(float f)
+{
+    return ::sinhf(f);
+}
+SLANG_FORCE_INLINE float F32_cosh(float f)
+{
+    return ::coshf(f);
+}
+SLANG_FORCE_INLINE float F32_tanh(float f)
+{
+    return ::tanhf(f);
+}
+SLANG_FORCE_INLINE float F32_log2(float f)
+{
+    return ::log2f(f);
+}
+SLANG_FORCE_INLINE float F32_log(float f)
+{
+    return ::logf(f);
+}
+SLANG_FORCE_INLINE float F32_log10(float f)
+{
+    return ::log10f(f);
+}
+SLANG_FORCE_INLINE float F32_exp2(float f)
+{
+    return ::exp2f(f);
+}
+SLANG_FORCE_INLINE float F32_exp(float f)
+{
+    return ::expf(f);
+}
+SLANG_FORCE_INLINE float F32_abs(float f)
+{
+    return ::fabsf(f);
+}
+SLANG_FORCE_INLINE float F32_trunc(float f)
+{
+    return ::truncf(f);
+}
+SLANG_FORCE_INLINE float F32_sqrt(float f)
+{
+    return ::sqrtf(f);
+}
 
-SLANG_FORCE_INLINE bool F32_isnan(float f) { return SLANG_PRELUDE_STD isnan(f); }
+SLANG_FORCE_INLINE bool F32_isnan(float f)
-SLANG_FORCE_INLINE bool F32_isfinite(float f) { return SLANG_PRELUDE_STD isfinite(f); }
+{
-SLANG_FORCE_INLINE bool F32_isinf(float f) { return SLANG_PRELUDE_STD isinf(f); }
+    return SLANG_PRELUDE_STD isnan(f);
+}
+SLANG_FORCE_INLINE bool F32_isfinite(float f)
+{
+    return SLANG_PRELUDE_STD isfinite(f);
+}
+SLANG_FORCE_INLINE bool F32_isinf(float f)
+{
+    return SLANG_PRELUDE_STD isinf(f);
+}
 
 // Binary
-SLANG_FORCE_INLINE float F32_min(float a, float b) { return ::fminf(a, b); }
+SLANG_FORCE_INLINE float F32_min(float a, float b)
-SLANG_FORCE_INLINE float F32_max(float a, float b) { return ::fmaxf(a, b); }
+{
-SLANG_FORCE_INLINE float F32_pow(float a, float b) { return ::powf(a, b); }
+    return ::fminf(a, b);
-SLANG_FORCE_INLINE float F32_fmod(float a, float b) { return ::fmodf(a, b); }
+}
-SLANG_FORCE_INLINE float F32_remainder(float a, float b) { return ::remainderf(a, b); }
+SLANG_FORCE_INLINE float F32_max(float a, float b)
-SLANG_FORCE_INLINE float F32_atan2(float a, float b) { return float(::atan2(a, b)); }
+{
+    return ::fmaxf(a, b);
+}
+SLANG_FORCE_INLINE float F32_pow(float a, float b)
+{
+    return ::powf(a, b);
+}
+SLANG_FORCE_INLINE float F32_fmod(float a, float b)
+{
+    return ::fmodf(a, b);
+}
+SLANG_FORCE_INLINE float F32_remainder(float a, float b)
+{
+    return ::remainderf(a, b);
+}
+SLANG_FORCE_INLINE float F32_atan2(float a, float b)
+{
+    return float(::atan2(a, b));
+}
 
-SLANG_FORCE_INLINE float F32_frexp(float x, int* e) { return ::frexpf(x, e); }
+SLANG_FORCE_INLINE float F32_frexp(float x, int* e)
+{
+    return ::frexpf(x, e);
+}
 
 SLANG_FORCE_INLINE float F32_modf(float x, float* ip)
 {
@@ -222,7 +344,10 @@ SLANG_FORCE_INLINE float F32_modf(float x, float* ip)
 }
 
 // Ternary
-SLANG_FORCE_INLINE float F32_fma(float a, float b, float c) { return ::fmaf(a, b, c); }
+SLANG_FORCE_INLINE float F32_fma(float a, float b, float c)
+{
+    return ::fmaf(a, b, c);
+}
 
 #endif
 
@@ -236,12 +361,31 @@ SLANG_FORCE_INLINE float F32_calcSafeRadians(float radians)
     return (a * float(SLANG_PRELUDE_PI * 2));
 }
 
-SLANG_FORCE_INLINE float F32_rsqrt(float f) { return 1.0f / F32_sqrt(f); }
+SLANG_FORCE_INLINE float F32_rsqrt(float f)
-SLANG_FORCE_INLINE float F32_sign(float f) { return ( f == 0.0f) ? f : (( f < 0.0f) ? -1.0f : 1.0f); } 
+{
-SLANG_FORCE_INLINE float F32_frac(float f) { return f - F32_floor(f); }
+    return 1.0f / F32_sqrt(f);
+}
+SLANG_FORCE_INLINE float F32_sign(float f)
+{
+    return (f == 0.0f) ? f : ((f < 0.0f) ? -1.0f : 1.0f);
+}
+SLANG_FORCE_INLINE float F32_frac(float f)
+{
+    return f - F32_floor(f);
+}
 
-SLANG_FORCE_INLINE uint32_t F32_asuint(float f) { Union32 u; u.f = f; return u.u; }
+SLANG_FORCE_INLINE uint32_t F32_asuint(float f)
-SLANG_FORCE_INLINE int32_t F32_asint(float f) { Union32 u; u.f = f; return u.i; }
+{
+    Union32 u;
+    u.f = f;
+    return u.u;
+}
+SLANG_FORCE_INLINE int32_t F32_asint(float f)
+{
+    Union32 u;
+    u.f = f;
+    return u.i;
+}
 
 // ----------------------------- F64 -----------------------------------------
 
@@ -278,8 +422,14 @@ bool F64_isfinite(double f);
 bool F64_isinf(double f);
 
 // Binary
-SLANG_FORCE_INLINE double F64_min(double a, double b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE double F64_min(double a, double b)
-SLANG_FORCE_INLINE double F64_max(double a, double b) { return a > b ? a : b; }
+{
+    return a < b ? a : b;
+}
+SLANG_FORCE_INLINE double F64_max(double a, double b)
+{
+    return a > b ? a : b;
+}
 double F64_pow(double a, double b);
 double F64_fmod(double a, double b);
 double F64_remainder(double a, double b);
@@ -290,48 +440,141 @@ double F64_frexp(double x, int* e);
 double F64_modf(double x, double* ip);
 
 // Ternary
-SLANG_FORCE_INLINE double F64_fma(double a, double b, double c) { return a * b + c; }
+SLANG_FORCE_INLINE double F64_fma(double a, double b, double c)
+{
+    return a * b + c;
+}
 
 SLANG_PRELUDE_EXTERN_C_END
 
 #else // SLANG_LLVM
 
 // Unary
-SLANG_FORCE_INLINE double F64_ceil(double f) { return ::ceil(f); }
+SLANG_FORCE_INLINE double F64_ceil(double f)
-SLANG_FORCE_INLINE double F64_floor(double f) { return ::floor(f); }
+{
-SLANG_FORCE_INLINE double F64_round(double f) { return ::round(f); }
+    return ::ceil(f);
-SLANG_FORCE_INLINE double F64_sin(double f) { return ::sin(f); }
+}
-SLANG_FORCE_INLINE double F64_cos(double f) { return ::cos(f); }
+SLANG_FORCE_INLINE double F64_floor(double f)
-SLANG_FORCE_INLINE double F64_tan(double f) { return ::tan(f); }
+{
-SLANG_FORCE_INLINE double F64_asin(double f) { return ::asin(f); }
+    return ::floor(f);
-SLANG_FORCE_INLINE double F64_acos(double f) { return ::acos(f); }
+}
-SLANG_FORCE_INLINE double F64_atan(double f) { return ::atan(f); }
+SLANG_FORCE_INLINE double F64_round(double f)
-SLANG_FORCE_INLINE double F64_sinh(double f) { return ::sinh(f); }
+{
-SLANG_FORCE_INLINE double F64_cosh(double f) { return ::cosh(f); }
+    return ::round(f);
-SLANG_FORCE_INLINE double F64_tanh(double f) { return ::tanh(f); }
+}
-SLANG_FORCE_INLINE double F64_log2(double f) { return ::log2(f); }
+SLANG_FORCE_INLINE double F64_sin(double f)
-SLANG_FORCE_INLINE double F64_log(double f) { return ::log(f); }
+{
-SLANG_FORCE_INLINE double F64_log10(float f) { return ::log10(f); }
+    return ::sin(f);
-SLANG_FORCE_INLINE double F64_exp2(double f) { return ::exp2(f); }
+}
-SLANG_FORCE_INLINE double F64_exp(double f) { return ::exp(f); }
+SLANG_FORCE_INLINE double F64_cos(double f)
-SLANG_FORCE_INLINE double F64_abs(double f) { return ::fabs(f); }
+{
-SLANG_FORCE_INLINE double F64_trunc(double f) { return ::trunc(f); }
+    return ::cos(f);
-SLANG_FORCE_INLINE double F64_sqrt(double f) { return ::sqrt(f); }
+}
+SLANG_FORCE_INLINE double F64_tan(double f)
+{
+    return ::tan(f);
+}
+SLANG_FORCE_INLINE double F64_asin(double f)
+{
+    return ::asin(f);
+}
+SLANG_FORCE_INLINE double F64_acos(double f)
+{
+    return ::acos(f);
+}
+SLANG_FORCE_INLINE double F64_atan(double f)
+{
+    return ::atan(f);
+}
+SLANG_FORCE_INLINE double F64_sinh(double f)
+{
+    return ::sinh(f);
+}
+SLANG_FORCE_INLINE double F64_cosh(double f)
+{
+    return ::cosh(f);
+}
+SLANG_FORCE_INLINE double F64_tanh(double f)
+{
+    return ::tanh(f);
+}
+SLANG_FORCE_INLINE double F64_log2(double f)
+{
+    return ::log2(f);
+}
+SLANG_FORCE_INLINE double F64_log(double f)
+{
+    return ::log(f);
+}
+SLANG_FORCE_INLINE double F64_log10(float f)
+{
+    return ::log10(f);
+}
+SLANG_FORCE_INLINE double F64_exp2(double f)
+{
+    return ::exp2(f);
+}
+SLANG_FORCE_INLINE double F64_exp(double f)
+{
+    return ::exp(f);
+}
+SLANG_FORCE_INLINE double F64_abs(double f)
+{
+    return ::fabs(f);
+}
+SLANG_FORCE_INLINE double F64_trunc(double f)
+{
+    return ::trunc(f);
+}
+SLANG_FORCE_INLINE double F64_sqrt(double f)
+{
+    return ::sqrt(f);
+}
 
 
-SLANG_FORCE_INLINE bool F64_isnan(double f) { return SLANG_PRELUDE_STD isnan(f); }
+SLANG_FORCE_INLINE bool F64_isnan(double f)
-SLANG_FORCE_INLINE bool F64_isfinite(double f) { return SLANG_PRELUDE_STD isfinite(f); }
+{
-SLANG_FORCE_INLINE bool F64_isinf(double f) { return SLANG_PRELUDE_STD isinf(f); }
+    return SLANG_PRELUDE_STD isnan(f);
+}
+SLANG_FORCE_INLINE bool F64_isfinite(double f)
+{
+    return SLANG_PRELUDE_STD isfinite(f);
+}
+SLANG_FORCE_INLINE bool F64_isinf(double f)
+{
+    return SLANG_PRELUDE_STD isinf(f);
+}
 
 // Binary
-SLANG_FORCE_INLINE double F64_min(double a, double b) { return ::fmin(a, b); }
+SLANG_FORCE_INLINE double F64_min(double a, double b)
-SLANG_FORCE_INLINE double F64_max(double a, double b) { return ::fmax(a, b); }
+{
-SLANG_FORCE_INLINE double F64_pow(double a, double b) { return ::pow(a, b); }
+    return ::fmin(a, b);
-SLANG_FORCE_INLINE double F64_fmod(double a, double b) { return ::fmod(a, b); }
+}
-SLANG_FORCE_INLINE double F64_remainder(double a, double b) { return ::remainder(a, b); }
+SLANG_FORCE_INLINE double F64_max(double a, double b)
-SLANG_FORCE_INLINE double F64_atan2(double a, double b) { return ::atan2(a, b); }
+{
+    return ::fmax(a, b);
+}
+SLANG_FORCE_INLINE double F64_pow(double a, double b)
+{
+    return ::pow(a, b);
+}
+SLANG_FORCE_INLINE double F64_fmod(double a, double b)
+{
+    return ::fmod(a, b);
+}
+SLANG_FORCE_INLINE double F64_remainder(double a, double b)
+{
+    return ::remainder(a, b);
+}
+SLANG_FORCE_INLINE double F64_atan2(double a, double b)
+{
+    return ::atan2(a, b);
+}
 
-SLANG_FORCE_INLINE double F64_frexp(double x, int* e) { return ::frexp(x, e); }
+SLANG_FORCE_INLINE double F64_frexp(double x, int* e)
+{
+    return ::frexp(x, e);
+}
 
 SLANG_FORCE_INLINE double F64_modf(double x, double* ip)
 {
@@ -339,13 +582,25 @@ SLANG_FORCE_INLINE double F64_modf(double x, double* ip)
 }
 
 // Ternary
-SLANG_FORCE_INLINE double F64_fma(double a, double b, double c) { return ::fma(a, b, c); }
+SLANG_FORCE_INLINE double F64_fma(double a, double b, double c)
+{
+    return ::fma(a, b, c);
+}
 
 #endif // SLANG_LLVM
 
-SLANG_FORCE_INLINE double F64_rsqrt(double f) { return 1.0 / F64_sqrt(f); }
+SLANG_FORCE_INLINE double F64_rsqrt(double f)
-SLANG_FORCE_INLINE double F64_sign(double f) { return (f == 0.0) ? f : ((f < 0.0) ? -1.0 : 1.0); }
+{
-SLANG_FORCE_INLINE double F64_frac(double f) { return f - F64_floor(f); }
+    return 1.0 / F64_sqrt(f);
+}
+SLANG_FORCE_INLINE double F64_sign(double f)
+{
+    return (f == 0.0) ? f : ((f < 0.0) ? -1.0 : 1.0);
+}
+SLANG_FORCE_INLINE double F64_frac(double f)
+{
+    return f - F64_floor(f);
+}
 
 SLANG_FORCE_INLINE void F64_asuint(double d, uint32_t* low, uint32_t* hi)
 {
@@ -375,13 +630,30 @@ SLANG_FORCE_INLINE double F64_calcSafeRadians(double radians)
 
 // ----------------------------- I32 -----------------------------------------
 
-SLANG_FORCE_INLINE int32_t I32_abs(int32_t f) { return (f < 0) ? -f : f; }
+SLANG_FORCE_INLINE int32_t I32_abs(int32_t f)
+{
+    return (f < 0) ? -f : f;
+}
 
-SLANG_FORCE_INLINE int32_t I32_min(int32_t a, int32_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE int32_t I32_min(int32_t a, int32_t b)
-SLANG_FORCE_INLINE int32_t I32_max(int32_t a, int32_t b) { return a > b ? a : b; }
+{
+    return a < b ? a : b;
+}
+SLANG_FORCE_INLINE int32_t I32_max(int32_t a, int32_t b)
+{
+    return a > b ? a : b;
+}
 
-SLANG_FORCE_INLINE float I32_asfloat(int32_t x) { Union32 u; u.i = x; return u.f; }
+SLANG_FORCE_INLINE float I32_asfloat(int32_t x)
-SLANG_FORCE_INLINE uint32_t I32_asuint(int32_t x) { return uint32_t(x); }
+{
+    Union32 u;
+    u.i = x;
+    return u.f;
+}
+SLANG_FORCE_INLINE uint32_t I32_asuint(int32_t x)
+{
+    return uint32_t(x);
+}
 SLANG_FORCE_INLINE double I32_asdouble(int32_t low, int32_t hi)
 {
     Union64 u;
@@ -391,13 +663,30 @@ SLANG_FORCE_INLINE double I32_asdouble(int32_t low, int32_t hi )
 
 // ----------------------------- U32 -----------------------------------------
 
-SLANG_FORCE_INLINE uint32_t U32_abs(uint32_t f) { return f; }
+SLANG_FORCE_INLINE uint32_t U32_abs(uint32_t f)
+{
+    return f;
+}
 
-SLANG_FORCE_INLINE uint32_t U32_min(uint32_t a, uint32_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE uint32_t U32_min(uint32_t a, uint32_t b)
-SLANG_FORCE_INLINE uint32_t U32_max(uint32_t a, uint32_t b) { return a > b ? a : b; }
+{
+    return a < b ? a : b;
+}
+SLANG_FORCE_INLINE uint32_t U32_max(uint32_t a, uint32_t b)
+{
+    return a > b ? a : b;
+}
 
-SLANG_FORCE_INLINE float U32_asfloat(uint32_t x) { Union32 u; u.u = x; return u.f; }
+SLANG_FORCE_INLINE float U32_asfloat(uint32_t x)
-SLANG_FORCE_INLINE uint32_t U32_asint(int32_t x) { return uint32_t(x); } 
+{
+    Union32 u;
+    u.u = x;
+    return u.f;
+}
+SLANG_FORCE_INLINE uint32_t U32_asint(int32_t x)
+{
+    return uint32_t(x);
+}
 
 SLANG_FORCE_INLINE double U32_asdouble(uint32_t low, uint32_t hi)
 {
@@ -426,12 +715,21 @@ SLANG_FORCE_INLINE uint32_t U32_countbits(uint32_t v)
 
 // ----------------------------- U64 -----------------------------------------
 
-SLANG_FORCE_INLINE uint64_t U64_abs(uint64_t f) { return f; }
+SLANG_FORCE_INLINE uint64_t U64_abs(uint64_t f)
+{
+    return f;
+}
 
-SLANG_FORCE_INLINE uint64_t U64_min(uint64_t a, uint64_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE uint64_t U64_min(uint64_t a, uint64_t b)
-SLANG_FORCE_INLINE uint64_t U64_max(uint64_t a, uint64_t b) { return a > b ? a : b; }
+{
+    return a < b ? a : b;
+}
+SLANG_FORCE_INLINE uint64_t U64_max(uint64_t a, uint64_t b)
+{
+    return a > b ? a : b;
+}
 
-// TODO(JS): We don't define countbits for 64bit in stdlib currently.
+// TODO(JS): We don't define countbits for 64bit in the core module currently.
 // It's not clear from documentation if it should return 32 or 64 bits, if it exists.
 // 32 bits can always hold the result, and will be implicitly promoted.
 SLANG_FORCE_INLINE uint32_t U64_countbits(uint64_t v)
@@ -453,11 +751,53 @@ SLANG_FORCE_INLINE uint32_t U64_countbits(uint64_t v)
 
 // ----------------------------- I64 -----------------------------------------
 
-SLANG_FORCE_INLINE int64_t I64_abs(int64_t f) { return (f < 0) ? -f : f; }
+SLANG_FORCE_INLINE int64_t I64_abs(int64_t f)
+{
+    return (f < 0) ? -f : f;
+}
 
-SLANG_FORCE_INLINE int64_t I64_min(int64_t a, int64_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE int64_t I64_min(int64_t a, int64_t b)
-SLANG_FORCE_INLINE int64_t I64_max(int64_t a, int64_t b) { return a > b ? a : b; }
+{
+    return a < b ? a : b;
+}
+SLANG_FORCE_INLINE int64_t I64_max(int64_t a, int64_t b)
+{
+    return a > b ? a : b;
+}
 
+// ----------------------------- UPTR -----------------------------------------
+
+SLANG_FORCE_INLINE uintptr_t UPTR_abs(uintptr_t f)
+{
+    return f;
+}
+
+SLANG_FORCE_INLINE uintptr_t UPTR_min(uintptr_t a, uintptr_t b)
+{
+    return a < b ? a : b;
+}
+
+SLANG_FORCE_INLINE uintptr_t UPTR_max(uintptr_t a, uintptr_t b)
+{
+    return a > b ? a : b;
+}
+
+// ----------------------------- IPTR -----------------------------------------
+
+SLANG_FORCE_INLINE intptr_t IPTR_abs(intptr_t f)
+{
+    return (f < 0) ? -f : f;
+}
+
+SLANG_FORCE_INLINE intptr_t IPTR_min(intptr_t a, intptr_t b)
+{
+    return a < b ? a : b;
+}
+
+SLANG_FORCE_INLINE intptr_t IPTR_max(intptr_t a, intptr_t b)
+{
+    return a > b ? a : b;
+}
 
 // ----------------------------- Interlocked ---------------------------------
 

include/vulkan/slang/slang-cpp-types-core.h

@@ -16,17 +16,20 @@
 // Asserts for bounds checking.
 // It is assumed index/count are unsigned types.
 #define SLANG_BOUND_ASSERT(index, count) SLANG_PRELUDE_ASSERT(index < count);
-#define SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);
+#define SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) \
+    SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);
 
 // Macros to zero index if an access is out of range
 #define SLANG_BOUND_ZERO_INDEX(index, count) index = (index < count) ? index : 0;
-#define SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes) index = (index <= (sizeInBytes - elemSize)) ? index : 0; 
+#define SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes) \
+    index = (index <= (sizeInBytes - elemSize)) ? index : 0;
 
-// The 'FIX' macro define how the index is fixed. The default is to do nothing. If SLANG_ENABLE_BOUND_ZERO_INDEX
+// The 'FIX' macro define how the index is fixed. The default is to do nothing. If
-// the fix macro will zero the index, if out of range
+// SLANG_ENABLE_BOUND_ZERO_INDEX the fix macro will zero the index, if out of range
 #ifdef SLANG_ENABLE_BOUND_ZERO_INDEX
 #define SLANG_BOUND_FIX(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
-#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
+#define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) \
+    SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
 #define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
 #else
 #define SLANG_BOUND_FIX(index, count)
@@ -35,15 +38,19 @@
 #endif
 
 #ifndef SLANG_BOUND_CHECK
-#   define SLANG_BOUND_CHECK(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX(index, count)
+#define SLANG_BOUND_CHECK(index, count) \
+    SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX(index, count)
 #endif
 
 #ifndef SLANG_BOUND_CHECK_BYTE_ADDRESS
-#   define SLANG_BOUND_CHECK_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
+#define SLANG_BOUND_CHECK_BYTE_ADDRESS(index, elemSize, sizeInBytes) \
+    SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes)    \
+    SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
 #endif
 
 #ifndef SLANG_BOUND_CHECK_FIXED_ARRAY
-#   define SLANG_BOUND_CHECK_FIXED_ARRAY(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX_FIXED_ARRAY(index, count)
+#define SLANG_BOUND_CHECK_FIXED_ARRAY(index, count) \
+    SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX_FIXED_ARRAY(index, count)
 #endif
 
 struct TypeInfo
@@ -54,25 +61,42 @@ struct TypeInfo
 template<typename T, size_t SIZE>
 struct FixedArray
 {
-    const T& operator[](size_t index) const { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
+    const T& operator[](size_t index) const
-    T& operator[](size_t index) { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
+    {
+        SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE);
+        return m_data[index];
+    }
+    T& operator[](size_t index)
+    {
+        SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE);
+        return m_data[index];
+    }
 
     T m_data[SIZE];
 };
 
-// An array that has no specified size, becomes a 'Array'. This stores the size so it can potentially 
+// An array that has no specified size, becomes a 'Array'. This stores the size so it can
-// do bounds checking.  
+// potentially do bounds checking.
 template<typename T>
 struct Array
 {
-    const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    const T& operator[](size_t index) const
-    T& operator[](size_t index) { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    T& operator[](size_t index)
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
 
     T* data;
     size_t count;
 };
 
-/* Constant buffers become a pointer to the contained type, so ConstantBuffer<T> becomes T* in C++ code.
+/* Constant buffers become a pointer to the contained type, so ConstantBuffer<T> becomes T* in C++
+ * code.
  */
 
 template<typename T, int COUNT>
@@ -86,10 +110,7 @@ struct Vector<T, 1>
     T& operator[](size_t /*index*/) { return x; }
     operator T() const { return x; }
     Vector() = default;
-    Vector(T scalar)
+    Vector(T scalar) { x = scalar; }
-    {
-        x = scalar;
-    }
     template<typename U>
     Vector(Vector<U, 1> other)
     {
@@ -99,7 +120,8 @@ struct Vector<T, 1>
     Vector(Vector<U, otherSize> other)
     {
         int minSize = 1;
-        if (otherSize < minSize) minSize = otherSize;
+        if (otherSize < minSize)
+            minSize = otherSize;
         for (int i = 0; i < minSize; i++)
             (*this)[i] = (T)other[i];
     }
@@ -112,10 +134,7 @@ struct Vector<T, 2>
     const T& operator[](size_t index) const { return index == 0 ? x : y; }
     T& operator[](size_t index) { return index == 0 ? x : y; }
     Vector() = default;
-    Vector(T scalar)
+    Vector(T scalar) { x = y = scalar; }
-    {
-        x = y = scalar;
-    }
     Vector(T _x, T _y)
     {
         x = _x;
@@ -131,7 +150,8 @@ struct Vector<T, 2>
     Vector(Vector<U, otherSize> other)
     {
         int minSize = 2;
-        if (otherSize < minSize) minSize = otherSize;
+        if (otherSize < minSize)
+            minSize = otherSize;
         for (int i = 0; i < minSize; i++)
             (*this)[i] = (T)other[i];
     }
@@ -145,10 +165,7 @@ struct Vector<T, 3>
     T& operator[](size_t index) { return *((T*)(this) + index); }
 
     Vector() = default;
-    Vector(T scalar)
+    Vector(T scalar) { x = y = z = scalar; }
-    {
-        x = y = z = scalar;
-    }
     Vector(T _x, T _y, T _z)
     {
         x = _x;
@@ -166,7 +183,8 @@ struct Vector<T, 3>
     Vector(Vector<U, otherSize> other)
     {
         int minSize = 3;
-        if (otherSize < minSize) minSize = otherSize;
+        if (otherSize < minSize)
+            minSize = otherSize;
         for (int i = 0; i < minSize; i++)
             (*this)[i] = (T)other[i];
     }
@@ -180,10 +198,7 @@ struct Vector<T, 4>
     const T& operator[](size_t index) const { return *((T*)(this) + index); }
     T& operator[](size_t index) { return *((T*)(this) + index); }
     Vector() = default;
-    Vector(T scalar)
+    Vector(T scalar) { x = y = z = w = scalar; }
-    {
-        x = y = z = w = scalar;
-    }
     Vector(T _x, T _y, T _z, T _w)
     {
         x = _x;
@@ -195,15 +210,18 @@ struct Vector<T, 4>
     Vector(Vector<U, otherSize> other)
     {
         int minSize = 4;
-        if (otherSize < minSize) minSize = otherSize;
+        if (otherSize < minSize)
+            minSize = otherSize;
         for (int i = 0; i < minSize; i++)
             (*this)[i] = (T)other[i];
     }
- 
 };
 
 template<typename T, int N>
-SLANG_FORCE_INLINE Vector<T, N> _slang_select(Vector<bool, N> condition, Vector<T, N> v0, Vector<T, N> v1)
+SLANG_FORCE_INLINE Vector<T, N> _slang_select(
+    Vector<bool, N> condition,
+    Vector<T, N> v0,
+    Vector<T, N> v1)
 {
     Vector<T, N> result;
     for (int i = 0; i < N; i++)
@@ -255,7 +273,9 @@ typedef uint32_t uint;
 
 #define SLANG_VECTOR_BINARY_OP(T, op)            \
     template<int n>                              \
-    SLANG_FORCE_INLINE Vector<T, n> operator op(const Vector<T, n>& thisVal, const Vector<T, n>& other) \
+    SLANG_FORCE_INLINE Vector<T, n> operator op( \
+        const Vector<T, n>& thisVal,             \
+        const Vector<T, n>& other)               \
     {                                            \
         Vector<T, n> result;                     \
         for (int i = 0; i < n; i++)              \
@@ -264,7 +284,9 @@ typedef uint32_t uint;
     }
 #define SLANG_VECTOR_BINARY_COMPARE_OP(T, op)       \
     template<int n>                                 \
-    SLANG_FORCE_INLINE Vector<bool, n> operator op(const Vector<T, n>& thisVal, const Vector<T, n>& other) \
+    SLANG_FORCE_INLINE Vector<bool, n> operator op( \
+        const Vector<T, n>& thisVal,                \
+        const Vector<T, n>& other)                  \
     {                                               \
         Vector<bool, n> result;                     \
         for (int i = 0; i < n; i++)                 \
@@ -370,6 +392,7 @@ template <typename T, int ROWS, int COLS>
 struct Matrix
 {
     Vector<T, COLS> rows[ROWS];
+    const Vector<T, COLS>& operator[](size_t index) const { return rows[index]; }
     Vector<T, COLS>& operator[](size_t index) { return rows[index]; }
     Matrix() = default;
     Matrix(T scalar)
@@ -377,10 +400,7 @@ struct Matrix
         for (int i = 0; i < ROWS; i++)
             rows[i] = Vector<T, COLS>(scalar);
     }
-    Matrix(const Vector<T, COLS>& row0)
+    Matrix(const Vector<T, COLS>& row0) { rows[0] = row0; }
-    {
-        rows[0] = row0;
-    }
     Matrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1)
     {
         rows[0] = row0;
@@ -392,7 +412,11 @@ struct Matrix
         rows[1] = row1;
         rows[2] = row2;
     }
-    Matrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1, const Vector<T, COLS>& row2, const Vector<T, COLS>& row3)
+    Matrix(
+        const Vector<T, COLS>& row0,
+        const Vector<T, COLS>& row1,
+        const Vector<T, COLS>& row2,
+        const Vector<T, COLS>& row3)
     {
         rows[0] = row0;
         rows[1] = row1;
@@ -404,74 +428,146 @@ struct Matrix
     {
         int minRow = ROWS;
         int minCol = COLS;
-        if (minRow > otherRow) minRow = otherRow;
+        if (minRow > otherRow)
-        if (minCol > otherCol) minCol = otherCol;
+            minRow = otherRow;
+        if (minCol > otherCol)
+            minCol = otherCol;
         for (int i = 0; i < minRow; i++)
             for (int j = 0; j < minCol; j++)
                 rows[i][j] = (T)other.rows[i][j];
     }
     Matrix(T v0, T v1, T v2, T v3)
     {
-        rows[0][0] = v0;  rows[0][1] = v1;
+        rows[0][0] = v0;
-        rows[1][0] = v2;  rows[1][1] = v3;
+        rows[0][1] = v1;
+        rows[1][0] = v2;
+        rows[1][1] = v3;
     }
     Matrix(T v0, T v1, T v2, T v3, T v4, T v5)
     {
         if (COLS == 3)
         {
-            rows[0][0] = v0;  rows[0][1] = v1; rows[0][2] = v2;
+            rows[0][0] = v0;
-            rows[1][0] = v3;  rows[1][1] = v4; rows[1][2] = v5;
+            rows[0][1] = v1;
+            rows[0][2] = v2;
+            rows[1][0] = v3;
+            rows[1][1] = v4;
+            rows[1][2] = v5;
         }
         else
         {
-            rows[0][0] = v0;  rows[0][1] = v1;
+            rows[0][0] = v0;
-            rows[1][0] = v2;  rows[1][1] = v3;
+            rows[0][1] = v1;
-            rows[2][0] = v4;  rows[2][1] = v5;
+            rows[1][0] = v2;
+            rows[1][1] = v3;
+            rows[2][0] = v4;
+            rows[2][1] = v5;
         }
     }
     Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7)
     {
         if (COLS == 4)
         {
-            rows[0][0] = v0;  rows[0][1] = v1; rows[0][2] = v2; rows[0][3] = v3;
+            rows[0][0] = v0;
-            rows[1][0] = v4;  rows[1][1] = v5; rows[1][2] = v6; rows[1][3] = v7;
+            rows[0][1] = v1;
+            rows[0][2] = v2;
+            rows[0][3] = v3;
+            rows[1][0] = v4;
+            rows[1][1] = v5;
+            rows[1][2] = v6;
+            rows[1][3] = v7;
         }
         else
         {
-            rows[0][0] = v0;  rows[0][1] = v1;
+            rows[0][0] = v0;
-            rows[1][0] = v2;  rows[1][1] = v3;
+            rows[0][1] = v1;
-            rows[2][0] = v4;  rows[2][1] = v5;
+            rows[1][0] = v2;
-            rows[3][0] = v6;  rows[3][1] = v7;
+            rows[1][1] = v3;
+            rows[2][0] = v4;
+            rows[2][1] = v5;
+            rows[3][0] = v6;
+            rows[3][1] = v7;
         }
     }
     Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8)
     {
-        rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;
+        rows[0][0] = v0;
-        rows[1][0] = v3;  rows[1][1] = v4;  rows[1][2] = v5;
+        rows[0][1] = v1;
-        rows[2][0] = v6;  rows[2][1] = v7;  rows[2][2] = v8;
+        rows[0][2] = v2;
+        rows[1][0] = v3;
+        rows[1][1] = v4;
+        rows[1][2] = v5;
+        rows[2][0] = v6;
+        rows[2][1] = v7;
+        rows[2][2] = v8;
     }
     Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11)
     {
         if (COLS == 4)
         {
-            rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;  rows[0][3] = v3;
+            rows[0][0] = v0;
-            rows[1][0] = v4;  rows[1][1] = v5;  rows[1][2] = v6;  rows[1][3] = v7;
+            rows[0][1] = v1;
-            rows[2][0] = v8;  rows[2][1] = v9;  rows[2][2] = v10; rows[2][3] = v11;
+            rows[0][2] = v2;
+            rows[0][3] = v3;
+            rows[1][0] = v4;
+            rows[1][1] = v5;
+            rows[1][2] = v6;
+            rows[1][3] = v7;
+            rows[2][0] = v8;
+            rows[2][1] = v9;
+            rows[2][2] = v10;
+            rows[2][3] = v11;
         }
         else
         {
-            rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;
+            rows[0][0] = v0;
-            rows[1][0] = v3;  rows[1][1] = v4;  rows[1][2] = v5;
+            rows[0][1] = v1;
-            rows[2][0] = v6;  rows[2][1] = v7;  rows[2][2] = v8;
+            rows[0][2] = v2;
-            rows[3][0] = v9;  rows[3][1] = v10; rows[3][2] = v11;
+            rows[1][0] = v3;
+            rows[1][1] = v4;
+            rows[1][2] = v5;
+            rows[2][0] = v6;
+            rows[2][1] = v7;
+            rows[2][2] = v8;
+            rows[3][0] = v9;
+            rows[3][1] = v10;
+            rows[3][2] = v11;
         }
     }
-    Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15)
+    Matrix(
+        T v0,
+        T v1,
+        T v2,
+        T v3,
+        T v4,
+        T v5,
+        T v6,
+        T v7,
+        T v8,
+        T v9,
+        T v10,
+        T v11,
+        T v12,
+        T v13,
+        T v14,
+        T v15)
     {
-        rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;  rows[0][3] = v3;
+        rows[0][0] = v0;
-        rows[1][0] = v4;  rows[1][1] = v5;  rows[1][2] = v6;  rows[1][3] = v7;
+        rows[0][1] = v1;
-        rows[2][0] = v8;  rows[2][1] = v9;  rows[2][2] = v10; rows[2][3] = v11;
+        rows[0][2] = v2;
-        rows[3][0] = v12; rows[3][1] = v13; rows[3][2] = v14; rows[3][3] = v15;
+        rows[0][3] = v3;
+        rows[1][0] = v4;
+        rows[1][1] = v5;
+        rows[1][2] = v6;
+        rows[1][3] = v7;
+        rows[2][0] = v8;
+        rows[2][1] = v9;
+        rows[2][2] = v10;
+        rows[2][3] = v11;
+        rows[3][0] = v12;
+        rows[3][1] = v13;
+        rows[3][2] = v14;
+        rows[3][3] = v15;
     }
 };
 
@@ -486,6 +582,17 @@ struct Matrix
         return result;                                                                        \
     }
 
+#define SLANG_MATRIX_BINARY_COMPARE_OP(T, op)                                                    \
+    template<int R, int C>                                                                       \
+    Matrix<bool, R, C> operator op(const Matrix<T, R, C>& thisVal, const Matrix<T, R, C>& other) \
+    {                                                                                            \
+        Matrix<bool, R, C> result;                                                               \
+        for (int i = 0; i < R; i++)                                                              \
+            for (int j = 0; j < C; j++)                                                          \
+                result.rows[i][j] = thisVal.rows[i][j] op other.rows[i][j];                      \
+        return result;                                                                           \
+    }
+
 #define SLANG_MATRIX_UNARY_OP(T, op)                            \
     template<int R, int C>                                      \
     Matrix<T, R, C> operator op(const Matrix<T, R, C>& thisVal) \
@@ -496,6 +603,7 @@ struct Matrix
                 result[i].rows[i][j] = op thisVal.rows[i][j];   \
         return result;                                          \
     }
+
 #define SLANG_INT_MATRIX_OPS(T)           \
     SLANG_MATRIX_BINARY_OP(T, +)          \
     SLANG_MATRIX_BINARY_OP(T, -)          \
@@ -507,6 +615,12 @@ struct Matrix
     SLANG_MATRIX_BINARY_OP(T, ||)         \
     SLANG_MATRIX_BINARY_OP(T, ^)          \
     SLANG_MATRIX_BINARY_OP(T, %)          \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, >)  \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, <)  \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, >=) \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, <=) \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, ==) \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, !=) \
     SLANG_MATRIX_UNARY_OP(T, !)           \
     SLANG_MATRIX_UNARY_OP(T, ~)
 #define SLANG_FLOAT_MATRIX_OPS(T)         \
@@ -514,7 +628,13 @@ struct Matrix
     SLANG_MATRIX_BINARY_OP(T, -)          \
     SLANG_MATRIX_BINARY_OP(T, *)          \
     SLANG_MATRIX_BINARY_OP(T, /)          \
-    SLANG_MATRIX_UNARY_OP(T, -)
+    SLANG_MATRIX_UNARY_OP(T, -)           \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, >)  \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, <)  \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, >=) \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, <=) \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, ==) \
+    SLANG_MATRIX_BINARY_COMPARE_OP(T, !=)
 SLANG_INT_MATRIX_OPS(int)
 SLANG_INT_MATRIX_OPS(int8_t)
 SLANG_INT_MATRIX_OPS(int16_t)
@@ -574,5 +694,3 @@ TResult slang_bit_cast(TInput val)
 }
 
 #endif
-
-

include/vulkan/slang/slang-cpp-types.h

@@ -2,7 +2,8 @@
 #define SLANG_PRELUDE_CPP_TYPES_H
 
 #ifdef SLANG_PRELUDE_NAMESPACE
-namespace SLANG_PRELUDE_NAMESPACE {
+namespace SLANG_PRELUDE_NAMESPACE
+{
 #endif
 
 #ifndef SLANG_FORCE_INLINE
@@ -23,8 +24,8 @@ typedef Vector<uint32_t, 2> uint2;
 typedef Vector<uint32_t, 3> uint3;
 typedef Vector<uint32_t, 4> uint4;
 
-// We can just map `NonUniformResourceIndex` type directly to the index type on CPU, as CPU does not require
+// We can just map `NonUniformResourceIndex` type directly to the index type on CPU, as CPU does not
-// any special handling around such accesses.
+// require any special handling around such accesses.
 typedef size_t NonUniformResourceIndex;
 
 // ----------------------------- ResourceType -----------------------------------------
@@ -35,9 +36,21 @@ typedef size_t NonUniformResourceIndex;
 template<typename T>
 struct RWStructuredBuffer
 {
-    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    SLANG_FORCE_INLINE T& operator[](size_t index) const
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }  
+    {
-    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride)
+    {
+        *outNumStructs = uint32_t(count);
+        *outStride = uint32_t(sizeof(T));
+    }
 
     T* data;
     size_t count;
@@ -46,9 +59,21 @@ struct RWStructuredBuffer
 template<typename T>
 struct StructuredBuffer
 {
-    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    SLANG_FORCE_INLINE const T& operator[](size_t index) const
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    {
-    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride)
+    {
+        *outNumStructs = uint32_t(count);
+        *outStride = uint32_t(sizeof(T));
+    }
 
     T* data;
     size_t count;
@@ -58,8 +83,16 @@ struct StructuredBuffer
 template<typename T>
 struct RWBuffer
 {
-    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    SLANG_FORCE_INLINE T& operator[](size_t index) const
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
     void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
 
     T* data;
@@ -69,8 +102,16 @@ struct RWBuffer
 template<typename T>
 struct Buffer
 {
-    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    SLANG_FORCE_INLINE const T& operator[](size_t index) const
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
     void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
 
     T* data;
@@ -349,17 +390,23 @@ struct TextureDimensions
 };
 
 
-
-
-
 // Texture
 
 struct ITexture
 {
     virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;
     virtual void Load(const int32_t* v, void* outData, size_t dataSize) = 0;
-    virtual void Sample(SamplerState samplerState, const float* loc, void* outData, size_t dataSize) = 0;
+    virtual void Sample(
-    virtual void SampleLevel(SamplerState samplerState, const float* loc, float level, void* outData, size_t dataSize) = 0;
+        SamplerState samplerState,
+        const float* loc,
+        void* outData,
+        size_t dataSize) = 0;
+    virtual void SampleLevel(
+        SamplerState samplerState,
+        const float* loc,
+        float level,
+        void* outData,
+        size_t dataSize) = 0;
 };
 
 template<typename T>
@@ -381,9 +428,24 @@ struct Texture1D
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int2& loc) const
-    T Sample(SamplerState samplerState, float loc) const { T out; texture->Sample(samplerState, &loc, &out, sizeof(out)); return out; }
+    {
-    T SampleLevel(SamplerState samplerState, float loc, float level) { T out; texture->SampleLevel(samplerState, &loc, level, &out, sizeof(out)); return out; }
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, float loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, float loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc, level, &out, sizeof(out));
+        return out;
+    }
 
     ITexture* texture;
 };
@@ -397,7 +459,11 @@ struct Texture2D
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -410,7 +476,11 @@ struct Texture2D
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -418,9 +488,24 @@ struct Texture2D
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int3& loc) const
-    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    {
-    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float2& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float2& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
 
     ITexture* texture;
 };
@@ -435,7 +520,12 @@ struct Texture3D
         *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outDepth,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -450,7 +540,12 @@ struct Texture3D
         *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outDepth,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -459,9 +554,24 @@ struct Texture3D
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int4& loc) const
-    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    {
-    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float3& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
 
     ITexture* texture;
 };
@@ -475,7 +585,11 @@ struct TextureCube
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -488,7 +602,11 @@ struct TextureCube
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -496,8 +614,18 @@ struct TextureCube
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T Sample(SamplerState samplerState, const float3& loc) const
-    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
 
     ITexture* texture;
 };
@@ -505,16 +633,34 @@ struct TextureCube
 template<typename T>
 struct Texture1DArray
 {
-    void GetDimensions(uint32_t* outWidth, uint32_t* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
+    void GetDimensions(uint32_t* outWidth, uint32_t* outElements)
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels) 
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outNumberOfLevels = dims.numberOfLevels;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(float* outWidth, float* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
+    void GetDimensions(float* outWidth, float* outElements)
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels) 
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -522,9 +668,24 @@ struct Texture1DArray
         *outElements = dims.arrayElementCount;
     }
 
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int3& loc) const
-    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    {
-    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float2& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float2& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
 
     ITexture* texture;
 };
@@ -539,7 +700,12 @@ struct Texture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -555,7 +721,12 @@ struct Texture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -564,9 +735,24 @@ struct Texture2DArray
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int4& loc) const
-    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    {
-    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float3& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
 
     ITexture* texture;
 };
@@ -581,7 +767,12 @@ struct TextureCubeArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -597,7 +788,12 @@ struct TextureCubeArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -606,8 +802,18 @@ struct TextureCubeArray
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Sample(SamplerState samplerState, const float4& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T Sample(SamplerState samplerState, const float4& loc) const
-    T SampleLevel(SamplerState samplerState, const float4& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float4& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
 
     ITexture* texture;
 };
@@ -624,12 +830,27 @@ template <typename T>
 struct RWTexture1D
 {
     void GetDimensions(uint32_t* outWidth) { *outWidth = texture->GetDimensions().width; }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
 
     void GetDimensions(float* outWidth) { *outWidth = texture->GetDimensions().width; }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
 
-    T Load(int32_t loc) const { T out; texture->Load(&loc, &out, sizeof(out)); return out; }
+    T Load(int32_t loc) const
+    {
+        T out;
+        texture->Load(&loc, &out, sizeof(out));
+        return out;
+    }
     T& operator[](uint32_t loc) { return *(T*)texture->refAt(&loc); }
     IRWTexture* texture;
 };
@@ -643,7 +864,11 @@ struct RWTexture2D
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -656,7 +881,11 @@ struct RWTexture2D
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -664,7 +893,12 @@ struct RWTexture2D
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int2& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](const uint2& loc) { return *(T*)texture->refAt(&loc.x); }
     IRWTexture* texture;
 };
@@ -679,7 +913,12 @@ struct RWTexture3D
         *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outDepth,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -694,7 +933,12 @@ struct RWTexture3D
         *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outDepth,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -703,7 +947,12 @@ struct RWTexture3D
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int3& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }
     IRWTexture* texture;
 };
@@ -718,7 +967,11 @@ struct RWTexture1DArray
         *outWidth = dims.width;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -731,7 +984,11 @@ struct RWTexture1DArray
         *outWidth = dims.width;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -739,7 +996,12 @@ struct RWTexture1DArray
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(int2 loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(int2 loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](uint2 loc) { return *(T*)texture->refAt(&loc.x); }
 
     IRWTexture* texture;
@@ -755,7 +1017,12 @@ struct RWTexture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -770,7 +1037,12 @@ struct RWTexture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -779,7 +1051,12 @@ struct RWTexture2DArray
         *outNumberOfLevels = dims.numberOfLevels;
     }
 
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Load(const int3& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }
 
     IRWTexture* texture;
@@ -787,21 +1064,47 @@ struct RWTexture2DArray
 
 // FeedbackTexture
 
-struct FeedbackType {};
+struct FeedbackType
-struct SAMPLER_FEEDBACK_MIN_MIP : FeedbackType {};
+{
-struct SAMPLER_FEEDBACK_MIP_REGION_USED : FeedbackType {};
+};
+struct SAMPLER_FEEDBACK_MIN_MIP : FeedbackType
+{
+};
+struct SAMPLER_FEEDBACK_MIP_REGION_USED : FeedbackType
+{
+};
 
 struct IFeedbackTexture
 {
     virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;
 
     // Note here we pass the optional clamp parameter as a pointer. Passing nullptr means no clamp.
-    // This was preferred over having two function definitions, and having to differentiate their names
+    // This was preferred over having two function definitions, and having to differentiate their
-    virtual void WriteSamplerFeedback(ITexture* tex, SamplerState samp, const float* location, const float* clamp = nullptr) = 0;
+    // names
-    virtual void WriteSamplerFeedbackBias(ITexture* tex, SamplerState samp, const float* location, float bias, const float* clamp = nullptr) = 0;
+    virtual void WriteSamplerFeedback(
-    virtual void WriteSamplerFeedbackGrad(ITexture* tex, SamplerState samp, const float* location, const float* ddx, const float* ddy, const float* clamp = nullptr) = 0;
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        const float* clamp = nullptr) = 0;
+    virtual void WriteSamplerFeedbackBias(
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        float bias,
+        const float* clamp = nullptr) = 0;
+    virtual void WriteSamplerFeedbackGrad(
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        const float* ddx,
+        const float* ddy,
+        const float* clamp = nullptr) = 0;
 
-    virtual void WriteSamplerFeedbackLevel(ITexture* tex, SamplerState samp, const float* location, float lod) = 0;
+    virtual void WriteSamplerFeedbackLevel(
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        float lod) = 0;
 };
 
 template<typename T>
@@ -813,7 +1116,11 @@ struct FeedbackTexture2D
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -826,7 +1133,11 @@ struct FeedbackTexture2D
         *outWidth = dims.width;
         *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -835,28 +1146,65 @@ struct FeedbackTexture2D
     }
 
     template<typename S>
-    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location, float clamp) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x, &clamp); } 
+    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location, float clamp)
+    {
+        texture->WriteSamplerFeedback(tex.texture, samp, &location.x, &clamp);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias, &clamp); }
+    void WriteSamplerFeedbackBias(
+        Texture2D<S> tex,
+        SamplerState samp,
+        float2 location,
+        float bias,
+        float clamp)
+    {
+        texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias, &clamp);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }
+    void WriteSamplerFeedbackGrad(
+        Texture2D<S> tex,
+        SamplerState samp,
+        float2 location,
+        float2 ddx,
+        float2 ddy,
+        float clamp)
+    {
+        texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp);
+    }
 
     // Level
 
     template<typename S>
-    void WriteSamplerFeedbackLevel(Texture2D<S> tex, SamplerState samp, float2 location, float lod) { texture->WriteSamplerFeedbackLevel(tex.texture, samp, &location.x, lod); }
+    void WriteSamplerFeedbackLevel(Texture2D<S> tex, SamplerState samp, float2 location, float lod)
+    {
+        texture->WriteSamplerFeedbackLevel(tex.texture, samp, &location.x, lod);
+    }
 
     // Without Clamp
     template<typename S>
-    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x); }
+    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location)
+    {
+        texture->WriteSamplerFeedback(tex.texture, samp, &location.x);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias); }
+    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias)
+    {
+        texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x); }
+    void WriteSamplerFeedbackGrad(
+        Texture2D<S> tex,
+        SamplerState samp,
+        float2 location,
+        float2 ddx,
+        float2 ddy)
+    {
+        texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x);
+    }
 
     IFeedbackTexture* texture;
 };
@@ -871,7 +1219,12 @@ struct FeedbackTexture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -886,7 +1239,12 @@ struct FeedbackTexture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -896,28 +1254,78 @@ struct FeedbackTexture2DArray
     }
 
     template<typename S>
-    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location, float clamp) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x, &clamp); }
+    void WriteSamplerFeedback(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float clamp)
+    {
+        texture->WriteSamplerFeedback(texArray.texture, samp, &location.x, &clamp);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias, &clamp); }
+    void WriteSamplerFeedbackBias(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float bias,
+        float clamp)
+    {
+        texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias, &clamp);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }
+    void WriteSamplerFeedbackGrad(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float3 ddx,
+        float3 ddy,
+        float clamp)
+    {
+        texture
+            ->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp);
+    }
 
     // Level
     template<typename S>
-    void WriteSamplerFeedbackLevel(Texture2DArray<S> texArray, SamplerState samp, float3 location, float lod) { texture->WriteSamplerFeedbackLevel(texArray.texture, samp, &location.x, lod); }
+    void WriteSamplerFeedbackLevel(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float lod)
+    {
+        texture->WriteSamplerFeedbackLevel(texArray.texture, samp, &location.x, lod);
+    }
 
     // Without Clamp
 
     template<typename S>
-    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x); }
+    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location)
+    {
+        texture->WriteSamplerFeedback(texArray.texture, samp, &location.x);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias); }
+    void WriteSamplerFeedbackBias(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float bias)
+    {
+        texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias);
+    }
 
     template<typename S>
-    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x); }
+    void WriteSamplerFeedbackGrad(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float3 ddx,
+        float3 ddy)
+    {
+        texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x);
+    }
 
     IFeedbackTexture* texture;
 };
@@ -937,16 +1345,20 @@ struct ComputeVaryingInput
     uint3 endGroupID;   ///< Non inclusive end groupID
 };
 
-// The uniformEntryPointParams and uniformState must be set to structures that match layout that the kernel expects.
+// The uniformEntryPointParams and uniformState must be set to structures that match layout that the
-// This can be determined via reflection for example.
+// kernel expects. This can be determined via reflection for example.
 
-typedef void(*ComputeThreadFunc)(ComputeThreadVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
+typedef void (*ComputeThreadFunc)(
-typedef void(*ComputeFunc)(ComputeVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
+    ComputeThreadVaryingInput* varyingInput,
+    void* uniformEntryPointParams,
+    void* uniformState);
+typedef void (*ComputeFunc)(
+    ComputeVaryingInput* varyingInput,
+    void* uniformEntryPointParams,
+    void* uniformState);
 
 #ifdef SLANG_PRELUDE_NAMESPACE
 }
 #endif
 
 #endif
-
-

include/vulkan/slang/slang-image-format-defs.h

@@ -45,5 +45,6 @@ SLANG_FORMAT(r16ui,           (UINT16,  1, sizeof(uint16_t)))
 SLANG_FORMAT(r8ui, (UINT8, 1, sizeof(uint8_t)))
 SLANG_FORMAT(r64ui, (UINT64, 1, sizeof(uint64_t)))
 SLANG_FORMAT(r64i, (INT64, 1, sizeof(int64_t)))
+SLANG_FORMAT(bgra8, (UINT8, 4, sizeof(uint32_t)))
 
 #undef SLANG_FORMAT

include/vulkan/slang/slang-llvm.h

@@ -9,7 +9,12 @@
 #ifndef SLANG_PRELUDE_ASSERT
 #ifdef SLANG_PRELUDE_ENABLE_ASSERT
 extern "C" void assertFailure(const char* msg);
-#       define SLANG_PRELUDE_EXPECT(VALUE, MSG) if(VALUE) {} else assertFailure("assertion failed: '" MSG "'")
+#define SLANG_PRELUDE_EXPECT(VALUE, MSG) \
+    if (VALUE)                           \
+    {                                    \
+    }                                    \
+    else                                 \
+        assertFailure("assertion failed: '" MSG "'")
 #define SLANG_PRELUDE_ASSERT(VALUE) SLANG_PRELUDE_EXPECT(VALUE, #VALUE)
 #else // SLANG_PRELUDE_ENABLE_ASSERT
 #define SLANG_PRELUDE_EXPECT(VALUE, MSG)
@@ -40,7 +45,10 @@ typedef __SIZE_TYPE__ rsize_t;
 #endif
 #ifdef __cplusplus
 #if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
-namespace std { typedef decltype(nullptr) nullptr_t; }
+namespace std
+{
+typedef decltype(nullptr) nullptr_t;
+}
 using ::std::nullptr_t;
 #endif
 #endif
@@ -394,5 +402,3 @@ typedef __UINTMAX_TYPE__ uintmax_t;
 
 
 #endif // SLANG_LLVM_H
-
-

include/vulkan/slang/slang-tag-version.h

@@ -1 +1 @@
-#define SLANG_TAG_VERSION "2024.13"
+#define SLANG_TAG_VERSION "2025.6.1"

include/vulkan/slang/slang-torch-prelude.h

@@ -1,11 +1,14 @@
 // Prelude for PyTorch cpp binding.
 
+// clang-format off
 #include <torch/extension.h>
+// clang-format on
+
 #include <ATen/cuda/CUDAContext.h>
 #include <ATen/cuda/CUDAUtils.h>
-#include <vector>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #ifdef SLANG_LLVM
 #include "slang-llvm.h"
@@ -19,9 +22,9 @@
 #endif
 
 #include <assert.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-#   include <stdint.h>
 #endif // SLANG_LLVM
 
 #include "../source/core/slang-string.h"
@@ -30,12 +33,15 @@
 #define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)
 #else
 #define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default")))
-//#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default")))
+// #   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport))
+// __attribute__((__visibility__("default")))
 #endif
 
 #ifdef __cplusplus
 #define SLANG_PRELUDE_EXTERN_C extern "C"
-#   define SLANG_PRELUDE_EXTERN_C_START extern "C" {
+#define SLANG_PRELUDE_EXTERN_C_START \
+    extern "C"                       \
+    {
 #define SLANG_PRELUDE_EXTERN_C_END }
 #else
 #define SLANG_PRELUDE_EXTERN_C
@@ -57,8 +63,8 @@
 #ifndef SLANG_FORCE_INLINE
 #define SLANG_FORCE_INLINE inline
 #endif
-#include "slang-cpp-types-core.h"
 #include "slang-cpp-scalar-intrinsics.h"
+#include "slang-cpp-types-core.h"
 
 
 static const int kSlangTorchTensorMaxDim = 5;
@@ -72,7 +78,11 @@ struct TensorView
 };
 
 
-TensorView make_tensor_view(torch::Tensor val, const char* name, torch::ScalarType targetScalarType, bool requireContiguous)
+TensorView make_tensor_view(
+    torch::Tensor val,
+    const char* name,
+    torch::ScalarType targetScalarType,
+    bool requireContiguous)
 {
     // We're currently not trying to implicitly cast or transfer to device for two reasons:
     // 1. There appears to be a bug with .to() where successive calls after the first one fail.
@@ -81,11 +91,13 @@ TensorView make_tensor_view(torch::Tensor val, const char* name, torch::ScalarTy
 
     // Expect tensors to be on CUDA device
     if (!val.device().is_cuda())
-        throw std::runtime_error(std::string(name).append(": tensor is not on CUDA device.").c_str());
+        throw std::runtime_error(
+            std::string(name).append(": tensor is not on CUDA device.").c_str());
 
     // Expect tensors to be the right type.
     if (val.dtype() != targetScalarType)
-        throw std::runtime_error(std::string(name).append(": tensor is not of the expected type.").c_str());
+        throw std::runtime_error(
+            std::string(name).append(": tensor is not of the expected type.").c_str());
 
     // Check that the tensor is contiguous
     if (requireContiguous && !val.is_contiguous())
@@ -138,14 +150,22 @@ TensorView make_tensor_view(torch::Tensor val, const char* name, torch::ScalarTy
     }
 
     if (val.dim() > kSlangTorchTensorMaxDim)
-        throw std::runtime_error(std::string(name).append(": number of dimensions exceeds limit (").append(std::to_string(kSlangTorchTensorMaxDim)).append(")").c_str());
+        throw std::runtime_error(std::string(name)
+                                     .append(": number of dimensions exceeds limit (")
+                                     .append(std::to_string(kSlangTorchTensorMaxDim))
+                                     .append(")")
+                                     .c_str());
 
     bool isEmpty = true;
     for (int i = 0; i < val.dim(); ++i)
     {
         res.strides[i] = val.stride(i) * elementSize;
         if (res.strides[i] == 0)
-            throw std::runtime_error(std::string(name).append(": tensors with broadcasted dimensions are not supported (use tensor.contiguous() to make tensor whole)").c_str());
+            throw std::runtime_error(
+                std::string(name)
+                    .append(": tensors with broadcasted dimensions are not supported (use "
+                            "tensor.contiguous() to make tensor whole)")
+                    .c_str());
 
         res.sizes[i] = val.size(i);
         if (res.sizes[i] > 0)

include/vulkan/spirv-headers/NonSemanticVkspReflection.h

@@ -33,7 +33,7 @@ extern "C" {
 #endif
 
 enum {
-    NonSemanticVkspReflectionRevision = 3,
+    NonSemanticVkspReflectionRevision = 4,
     NonSemanticVkspReflectionRevision_BitWidthPadding = 0x7fffffff
 };
 

include/vulkan/spirv-headers/extinst.nonsemantic.vkspreflection.grammar.json

@@ -1,26 +1,26 @@
 {
-  "revision" : 3,
+  "revision" : 4,
   "instructions" : [
     {
       "opname" : "Configuration",
       "opcode" : 1,
       "operands" : [
-        {"kind" : "LiteralString", "name" : "enabledExtensionNames" },
+        {"kind" : "IdRef", "name" : "enabledExtensionNames" },
-        {"kind" : "LiteralInteger", "name" : "specializationInfoDataSize" },
+        {"kind" : "IdRef", "name" : "specializationInfoDataSize" },
-        {"kind" : "LiteralString", "name" : "specializationInfoData" },
+        {"kind" : "IdRef", "name" : "specializationInfoData" },
-        {"kind" : "LiteralString", "name" : "shaderName" },
+        {"kind" : "IdRef", "name" : "shaderName" },
-        {"kind" : "LiteralString", "name" : "EntryPoint" },
+        {"kind" : "IdRef", "name" : "EntryPoint" },
-        {"kind" : "LiteralInteger", "name" : "groupCountX" },
+        {"kind" : "IdRef", "name" : "groupCountX" },
-        {"kind" : "LiteralInteger", "name" : "groupCountY" },
+        {"kind" : "IdRef", "name" : "groupCountY" },
-        {"kind" : "LiteralInteger", "name" : "groupCountZ" },
+        {"kind" : "IdRef", "name" : "groupCountZ" },
-        {"kind" : "LiteralInteger", "name" : "dispatchId" }
+        {"kind" : "IdRef", "name" : "dispatchId" }
       ]
     },
     {
       "opname" : "StartCounter",
       "opcode" : 2,
       "operands" : [
-        {"kind" : "LiteralString", "name" : "name" }
+        {"kind" : "IdRef", "name" : "name" }
       ]
     },
     {
@@ -34,104 +34,104 @@
       "opname" : "PushConstants",
       "opcode" : 4,
       "operands" : [
-        { "kind" : "LiteralInteger", "name" : "offset" },
+        { "kind" : "IdRef", "name" : "offset" },
-        { "kind" : "LiteralInteger", "name" : "size" },
+        { "kind" : "IdRef", "name" : "size" },
-        { "kind" : "LiteralString", "name" : "pValues" },
+        { "kind" : "IdRef", "name" : "pValues" },
-        { "kind" : "LiteralInteger", "name" : "stageFlags" }
+        { "kind" : "IdRef", "name" : "stageFlags" }
       ]
     },
     {
       "opname" : "SpecializationMapEntry",
       "opcode" : 5,
       "operands" : [
-        {"kind" : "LiteralInteger", "name" : "constantID" },
+        {"kind" : "IdRef", "name" : "constantID" },
-        {"kind" : "LiteralInteger", "name" : "offset" },
+        {"kind" : "IdRef", "name" : "offset" },
-        {"kind" : "LiteralInteger", "name" : "size" }
+        {"kind" : "IdRef", "name" : "size" }
       ]
     },
     {
       "opname" : "DescriptorSetBuffer",
       "opcode" : 6,
       "operands" : [
-        { "kind" : "LiteralInteger", "name" : "ds" },
+        { "kind" : "IdRef", "name" : "ds" },
-        { "kind" : "LiteralInteger", "name" : "binding" },
+        { "kind" : "IdRef", "name" : "binding" },
-        { "kind" : "LiteralInteger", "name" : "type" },
+        { "kind" : "IdRef", "name" : "type" },
-        { "kind" : "LiteralInteger", "name" : "flags" },
+        { "kind" : "IdRef", "name" : "flags" },
-        { "kind" : "LiteralInteger", "name" : "queueFamilyIndexCount" },
+        { "kind" : "IdRef", "name" : "queueFamilyIndexCount" },
-        { "kind" : "LiteralInteger", "name" : "sharingMode" },
+        { "kind" : "IdRef", "name" : "sharingMode" },
-        { "kind" : "LiteralInteger", "name" : "size" },
+        { "kind" : "IdRef", "name" : "size" },
-        { "kind" : "LiteralInteger", "name" : "usage" },
+        { "kind" : "IdRef", "name" : "usage" },
-        { "kind" : "LiteralInteger", "name" : "range" },
+        { "kind" : "IdRef", "name" : "range" },
-        { "kind" : "LiteralInteger", "name" : "offset" },
+        { "kind" : "IdRef", "name" : "offset" },
-        { "kind" : "LiteralInteger", "name" : "memorySize" },
+        { "kind" : "IdRef", "name" : "memorySize" },
-        { "kind" : "LiteralInteger", "name" : "memoryType" },
+        { "kind" : "IdRef", "name" : "memoryType" },
-        { "kind" : "LiteralInteger", "name" : "bindOffset" },
+        { "kind" : "IdRef", "name" : "bindOffset" },
-        { "kind" : "LiteralInteger", "name" : "viewFlags" },
+        { "kind" : "IdRef", "name" : "viewFlags" },
-        { "kind" : "LiteralInteger", "name" : "viewFormat" }
+        { "kind" : "IdRef", "name" : "viewFormat" }
       ]
     },
     {
       "opname" : "DescriptorSetImage",
       "opcode" : 7,
       "operands" : [
-        { "kind" : "LiteralInteger", "name" : "ds" },
+        { "kind" : "IdRef", "name" : "ds" },
-        { "kind" : "LiteralInteger", "name" : "binding" },
+        { "kind" : "IdRef", "name" : "binding" },
-        { "kind" : "LiteralInteger", "name" : "type" },
+        { "kind" : "IdRef", "name" : "type" },
-        { "kind" : "LiteralInteger", "name" : "imageLayout"},
+        { "kind" : "IdRef", "name" : "imageLayout"},
-        { "kind" : "LiteralInteger", "name" : "imageFlags"},
+        { "kind" : "IdRef", "name" : "imageFlags"},
-        { "kind" : "LiteralInteger", "name" : "imageType"},
+        { "kind" : "IdRef", "name" : "imageType"},
-        { "kind" : "LiteralInteger", "name" : "imageformat"},
+        { "kind" : "IdRef", "name" : "imageformat"},
-        { "kind" : "LiteralInteger", "name" : "width"},
+        { "kind" : "IdRef", "name" : "width"},
-        { "kind" : "LiteralInteger", "name" : "height"},
+        { "kind" : "IdRef", "name" : "height"},
-        { "kind" : "LiteralInteger", "name" : "depth"},
+        { "kind" : "IdRef", "name" : "depth"},
-        { "kind" : "LiteralInteger", "name" : "mipLevels"},
+        { "kind" : "IdRef", "name" : "mipLevels"},
-        { "kind" : "LiteralInteger", "name" : "arrayLayers"},
+        { "kind" : "IdRef", "name" : "arrayLayers"},
-        { "kind" : "LiteralInteger", "name" : "samples"},
+        { "kind" : "IdRef", "name" : "samples"},
-        { "kind" : "LiteralInteger", "name" : "tiling"},
+        { "kind" : "IdRef", "name" : "tiling"},
-        { "kind" : "LiteralInteger", "name" : "usage"},
+        { "kind" : "IdRef", "name" : "usage"},
-        { "kind" : "LiteralInteger", "name" : "sharingMode"},
+        { "kind" : "IdRef", "name" : "sharingMode"},
-        { "kind" : "LiteralInteger", "name" : "queueFamilyIndexCount"},
+        { "kind" : "IdRef", "name" : "queueFamilyIndexCount"},
-        { "kind" : "LiteralInteger", "name" : "initialLayout"},
+        { "kind" : "IdRef", "name" : "initialLayout"},
-        { "kind" : "LiteralInteger", "name" : "aspectMask"},
+        { "kind" : "IdRef", "name" : "aspectMask"},
-        { "kind" : "LiteralInteger", "name" : "baseMipLevel"},
+        { "kind" : "IdRef", "name" : "baseMipLevel"},
-        { "kind" : "LiteralInteger", "name" : "levelCount"},
+        { "kind" : "IdRef", "name" : "levelCount"},
-        { "kind" : "LiteralInteger", "name" : "baseArrayLayer"},
+        { "kind" : "IdRef", "name" : "baseArrayLayer"},
-        { "kind" : "LiteralInteger", "name" : "layerCount"},
+        { "kind" : "IdRef", "name" : "layerCount"},
-        { "kind" : "LiteralInteger", "name" : "viewFlags"},
+        { "kind" : "IdRef", "name" : "viewFlags"},
-        { "kind" : "LiteralInteger", "name" : "viewType"},
+        { "kind" : "IdRef", "name" : "viewType"},
-        { "kind" : "LiteralInteger", "name" : "viewFormat"},
+        { "kind" : "IdRef", "name" : "viewFormat"},
-        { "kind" : "LiteralInteger", "name" : "component_a"},
+        { "kind" : "IdRef", "name" : "component_a"},
-        { "kind" : "LiteralInteger", "name" : "component_b"},
+        { "kind" : "IdRef", "name" : "component_b"},
-        { "kind" : "LiteralInteger", "name" : "component_g"},
+        { "kind" : "IdRef", "name" : "component_g"},
-        { "kind" : "LiteralInteger", "name" : "component_r"},
+        { "kind" : "IdRef", "name" : "component_r"},
-        { "kind" : "LiteralInteger", "name" : "memorySize" },
+        { "kind" : "IdRef", "name" : "memorySize" },
-        { "kind" : "LiteralInteger", "name" : "memoryType" },
+        { "kind" : "IdRef", "name" : "memoryType" },
-        { "kind" : "LiteralInteger", "name" : "bindOffset"}
+        { "kind" : "IdRef", "name" : "bindOffset"}
       ]
     },
     {
       "opname" : "DescriptorSetSampler",
       "opcode" : 8,
       "operands" : [
-        { "kind" : "LiteralInteger", "name" : "ds" },
+        { "kind" : "IdRef", "name" : "ds" },
-        { "kind" : "LiteralInteger", "name" : "binding" },
+        { "kind" : "IdRef", "name" : "binding" },
-        { "kind" : "LiteralInteger", "name" : "type" },
+        { "kind" : "IdRef", "name" : "type" },
-        { "kind" : "LiteralInteger", "name" : "flags"},
+        { "kind" : "IdRef", "name" : "flags"},
-        { "kind" : "LiteralInteger", "name" : "magFilter"},
+        { "kind" : "IdRef", "name" : "magFilter"},
-        { "kind" : "LiteralInteger", "name" : "minFilter"},
+        { "kind" : "IdRef", "name" : "minFilter"},
-        { "kind" : "LiteralInteger", "name" : "mipmapMode"},
+        { "kind" : "IdRef", "name" : "mipmapMode"},
-        { "kind" : "LiteralInteger", "name" : "addressModeU"},
+        { "kind" : "IdRef", "name" : "addressModeU"},
-        { "kind" : "LiteralInteger", "name" : "addressModeV"},
+        { "kind" : "IdRef", "name" : "addressModeV"},
-        { "kind" : "LiteralInteger", "name" : "addressModeW"},
+        { "kind" : "IdRef", "name" : "addressModeW"},
-        { "kind" : "LiteralFloat", "name" : "mipLodBias"},
+        { "kind" : "IdRef", "name" : "mipLodBias"},
-        { "kind" : "LiteralInteger", "name" : "anisotropyEnable"},
+        { "kind" : "IdRef", "name" : "anisotropyEnable"},
-        { "kind" : "LiteralFloat", "name" : "maxAnisotropy"},
+        { "kind" : "IdRef", "name" : "maxAnisotropy"},
-        { "kind" : "LiteralInteger", "name" : "compareEnable"},
+        { "kind" : "IdRef", "name" : "compareEnable"},
-        { "kind" : "LiteralInteger", "name" : "compareOp"},
+        { "kind" : "IdRef", "name" : "compareOp"},
-        { "kind" : "LiteralFloat", "name" : "minLod"},
+        { "kind" : "IdRef", "name" : "minLod"},
-        { "kind" : "LiteralFloat", "name" : "maxLod"},
+        { "kind" : "IdRef", "name" : "maxLod"},
-        { "kind" : "LiteralInteger", "name" : "borderColor"},
+        { "kind" : "IdRef", "name" : "borderColor"},
-        { "kind" : "LiteralInteger", "name" : "unnormalizedCoordinates"}
+        { "kind" : "IdRef", "name" : "unnormalizedCoordinates"}
       ]
     }
   ]

include/vulkan/spirv-headers/spir-v.xml

@@ -95,7 +95,9 @@
         <id value="42"  vendor="Rendong Liang" tool="spq" comment="Contact Rendong Liang, admin@penguinliong.moe, https://github.com/PENGUINLIONG/spq-rs"/>
         <id value="43"  vendor="LLVM" tool="LLVM SPIR-V Backend" comment="Contact Michal Paszkowski, michal.paszkowski@intel.com, https://github.com/llvm/llvm-project/tree/main/llvm/lib/Target/SPIRV"/>
         <id value="44"  vendor="Robert Konrad" tool="Kongruent" comment="Contact Robert Konrad, https://github.com/Kode/Kongruent"/>
-        <unused start="45" end="0xFFFF" comment="Tool ID range reservable for future use by vendors"/>
+        <id value="45"  vendor="Kitsunebi Games" tool="Nuvk SPIR-V Emitter and DLSL compiler" comment="Contact Luna Nielsen, luna@foxgirls.gay, https://github.com/Inochi2D/nuvk"/>
+        <id value="46"  vendor="Nintendo" comment="Contact Steve Urquhart, steve.urquhart@ntd.nintendo.com"/>
+        <unused start="47" end="0xFFFF" comment="Tool ID range reservable for future use by vendors"/>
     </ids>
 
     <!-- SECTION: SPIR-V Opcodes and Enumerants -->
@@ -152,13 +154,14 @@
     <ids type="opcode" start="6528" end="6591" vendor="Codeplay" comment="Contact duncan.brawley@codeplay.com"/>
     <ids type="opcode" start="6592" end="6655" vendor="Saarland University" comment="Contact devillers@cg.uni-saarland.de"/>
     <ids type="opcode" start="6656" end="6719" vendor="Meta" comment="Contact dunfanlu@meta.com"/>
+    <ids type="opcode" start="6720" end="6783" vendor="MediaTek" comment="Contact samuel.huang@mediatek.com"/>
     <!-- Opcode enumerants to reserve for future use. To get a block, allocate
          multiples of 64 starting at the lowest available point in this
          block and add a corresponding <ids> tag immediately above. Make
          sure to fill in the vendor attribute, and preferably add a contact
          person/address in a comment attribute. -->
     <!-- Example new block: <ids type="opcode" start="XXXX" end="XXXX+64n-1" vendor="Add vendor" comment="Contact TBD"/> -->
-    <ids type="opcode" start="6720" end="65535" comment="Opcode range reservable for future use by vendors"/>
+    <ids type="opcode" start="6784" end="65535" comment="Opcode range reservable for future use by vendors"/>
     <!-- End reservations of opcodes -->
 
 
@@ -185,13 +188,14 @@
     <ids type="enumerant" start="6528" end="6591" vendor="Codeplay" comment="Contact duncan.brawley@codeplay.com"/>
     <ids type="enumerant" start="6592" end="6655" vendor="Saarland University" comment="Contact devillers@cg.uni-saarland.de"/>
     <ids type="enumerant" start="6656" end="6719" vendor="Meta" comment="Contact dunfanlu@meta.com"/>
+    <ids type="enumerant" start="6720" end="6783" vendor="MediaTek" comment="Contact samuel.huang@mediatek.com"/>
     <!-- Enumerants to reserve for future use. To get a block, allocate
          multiples of 64 starting at the lowest available point in this
          block and add a corresponding <ids> tag immediately above. Make
          sure to fill in the vendor attribute, and preferably add a contact
          person/address in a comment attribute. -->
     <!-- Example new block: <ids type="enumerant" start="XXXX" end="XXXX+64n-1" vendor="Add vendor" comment="Contact TBD"/> -->
-    <ids type="enumerant" start="6720" end="4294967295" comment="Enumerant range reservable for future use by vendors"/>
+    <ids type="enumerant" start="6784" end="4294967295" comment="Enumerant range reservable for future use by vendors"/>
     <!-- End reservations of enumerants -->
 
 

include/vulkan/spirv-headers/spirv.bf

@@ -71,6 +71,7 @@ namespace Spv
             WGSL = 10,
             Slang = 11,
             Zig = 12,
+            Rust = 13,
             Max = 0x7fffffff,
         }
 
@@ -175,6 +176,7 @@ namespace Spv
             EarlyAndLateFragmentTestsAMD = 5017,
             StencilRefReplacingEXT = 5027,
             CoalescingAMDX = 5069,
+            IsApiEntryAMDX = 5070,
             MaxNodeRecursionAMDX = 5071,
             StaticNumWorkgroupsAMDX = 5072,
             ShaderIndexAMDX = 5073,
@@ -187,6 +189,7 @@ namespace Spv
             StencilRefLessBackAMD = 5084,
             QuadDerivativesKHR = 5088,
             RequireFullQuadsKHR = 5089,
+            SharesInputWithAMDX = 5102,
             OutputLinesEXT = 5269,
             OutputLinesNV = 5269,
             OutputPrimitivesEXT = 5270,
@@ -241,7 +244,6 @@ namespace Spv
             StorageBuffer = 12,
             TileImageEXT = 4172,
             NodePayloadAMDX = 5068,
-            NodeOutputPayloadAMDX = 5076,
             CallableDataKHR = 5328,
             CallableDataNV = 5328,
             IncomingCallableDataKHR = 5329,
@@ -569,6 +571,10 @@ namespace Spv
             NodeMaxPayloadsAMDX = 5020,
             TrackFinishWritingAMDX = 5078,
             PayloadNodeNameAMDX = 5091,
+            PayloadNodeBaseIndexAMDX = 5098,
+            PayloadNodeSparseArrayAMDX = 5099,
+            PayloadNodeArraySizeAMDX = 5100,
+            PayloadDispatchIndirectAMDX = 5105,
             OverrideCoverageNV = 5248,
             PassthroughNV = 5250,
             ViewportRelativeNV = 5252,
@@ -733,7 +739,7 @@ namespace Spv
             BaryCoordSmoothSampleAMD = 4997,
             BaryCoordPullModelAMD = 4998,
             FragStencilRefEXT = 5014,
-            CoalescedInputCountAMDX = 5021,
+            RemainingRecursionLevelsAMDX = 5021,
             ShaderIndexAMDX = 5073,
             ViewportMaskNV = 5253,
             SecondaryPositionNV = 5257,
@@ -793,12 +799,19 @@ namespace Spv
             IncomingRayFlagsKHR = 5351,
             IncomingRayFlagsNV = 5351,
             RayGeometryIndexKHR = 5352,
+            HitIsSphereNV = 5359,
+            HitIsLSSNV = 5360,
+            HitSpherePositionNV = 5361,
             WarpsPerSMNV = 5374,
             SMCountNV = 5375,
             WarpIDNV = 5376,
             SMIDNV = 5377,
+            HitLSSPositionsNV = 5396,
             HitKindFrontFacingMicroTriangleNV = 5405,
             HitKindBackFacingMicroTriangleNV = 5406,
+            HitSphereRadiusNV = 5420,
+            HitLSSRadiiNV = 5421,
+            ClusterIDNV = 5436,
             CullMaskKHR = 6021,
             Max = 0x7fffffff,
         }
@@ -871,6 +884,7 @@ namespace Spv
             DontInline = 1,
             Pure = 2,
             Const = 3,
+            OptNoneEXT = 16,
             OptNoneINTEL = 16,
             Max = 0x7fffffff,
         }
@@ -882,6 +896,7 @@ namespace Spv
             DontInline = 0x00000002,
             Pure = 0x00000004,
             Const = 0x00000008,
+            OptNoneEXT = 0x00010000,
             OptNoneINTEL = 0x00010000,
         }
 
@@ -1194,9 +1209,20 @@ namespace Spv
             ShaderInvocationReorderNV = 5383,
             BindlessTextureNV = 5390,
             RayQueryPositionFetchKHR = 5391,
+            CooperativeVectorNV = 5394,
             AtomicFloat16VectorNV = 5404,
             RayTracingDisplacementMicromapNV = 5409,
             RawAccessChainsNV = 5414,
+            RayTracingSpheresGeometryNV = 5418,
+            RayTracingLinearSweptSpheresGeometryNV = 5419,
+            CooperativeMatrixReductionsNV = 5430,
+            CooperativeMatrixConversionsNV = 5431,
+            CooperativeMatrixPerElementOperationsNV = 5432,
+            CooperativeMatrixTensorAddressingNV = 5433,
+            CooperativeMatrixBlockLoadsNV = 5434,
+            CooperativeVectorTrainingNV = 5435,
+            RayTracingClusterAccelerationStructureNV = 5437,
+            TensorAddressingNV = 5439,
             SubgroupShuffleINTEL = 5568,
             SubgroupBufferBlockIOINTEL = 5569,
             SubgroupImageBlockIOINTEL = 5570,
@@ -1256,11 +1282,13 @@ namespace Spv
             AtomicFloat32AddEXT = 6033,
             AtomicFloat64AddEXT = 6034,
             LongCompositesINTEL = 6089,
+            OptNoneEXT = 6094,
             OptNoneINTEL = 6094,
             AtomicFloat16AddEXT = 6095,
             DebugInfoModuleINTEL = 6114,
             BFloat16ConversionINTEL = 6115,
             SplitBarrierINTEL = 6141,
+            ArithmeticFenceEXT = 6144,
             FPGAClusterAttributesV2INTEL = 6150,
             FPGAKernelAttributesv2INTEL = 6161,
             FPMaxErrorINTEL = 6169,
@@ -1269,6 +1297,10 @@ namespace Spv
             GlobalVariableHostAccessINTEL = 6187,
             GlobalVariableFPGADecorationsINTEL = 6189,
             SubgroupBufferPrefetchINTEL = 6220,
+            Subgroup2DBlockIOINTEL = 6228,
+            Subgroup2DBlockTransformINTEL = 6229,
+            Subgroup2DBlockTransposeINTEL = 6230,
+            SubgroupMatrixMultiplyAccumulateINTEL = 6236,
             GroupUniformArithmeticKHR = 6400,
             MaskedGatherScatterINTEL = 6427,
             CacheControlsINTEL = 6441,
@@ -1286,6 +1318,7 @@ namespace Spv
             CullFrontFacingTrianglesKHR = 5,
             CullOpaqueKHR = 6,
             CullNoOpaqueKHR = 7,
+            SkipBuiltinPrimitivesNV = 8,
             SkipTrianglesKHR = 8,
             SkipAABBsKHR = 9,
             ForceOpacityMicromap2StateEXT = 10,
@@ -1303,6 +1336,7 @@ namespace Spv
             CullFrontFacingTrianglesKHR = 0x00000020,
             CullOpaqueKHR = 0x00000040,
             CullNoOpaqueKHR = 0x00000080,
+            SkipBuiltinPrimitivesNV = 0x00000100,
             SkipTrianglesKHR = 0x00000100,
             SkipAABBsKHR = 0x00000200,
             ForceOpacityMicromap2StateEXT = 0x00000400,
@@ -1428,6 +1462,46 @@ namespace Spv
             Max = 0x7fffffff,
         }
 
+        [AllowDuplicates, CRepr] public enum CooperativeMatrixReduceShift
+        {
+            Row = 0,
+            Column = 1,
+            CooperativeMatrixReduce2x2 = 2,
+            Max = 0x7fffffff,
+        }
+
+        [AllowDuplicates, CRepr] public enum CooperativeMatrixReduceMask
+        {
+            MaskNone = 0,
+            Row = 0x00000001,
+            Column = 0x00000002,
+            CooperativeMatrixReduce2x2 = 0x00000004,
+        }
+
+        [AllowDuplicates, CRepr] public enum TensorClampMode
+        {
+            Undefined = 0,
+            Constant = 1,
+            ClampToEdge = 2,
+            Repeat = 3,
+            RepeatMirrored = 4,
+            Max = 0x7fffffff,
+        }
+
+        [AllowDuplicates, CRepr] public enum TensorAddressingOperandsShift
+        {
+            TensorView = 0,
+            DecodeFunc = 1,
+            Max = 0x7fffffff,
+        }
+
+        [AllowDuplicates, CRepr] public enum TensorAddressingOperandsMask
+        {
+            MaskNone = 0,
+            TensorView = 0x00000001,
+            DecodeFunc = 0x00000002,
+        }
+
         [AllowDuplicates, CRepr] public enum InitializationModeQualifier
         {
             InitOnDeviceReprogramINTEL = 0,
@@ -1469,6 +1543,44 @@ namespace Spv
             Max = 0x7fffffff,
         }
 
+        [AllowDuplicates, CRepr] public enum MatrixMultiplyAccumulateOperandsShift
+        {
+            MatrixASignedComponentsINTEL = 0,
+            MatrixBSignedComponentsINTEL = 1,
+            MatrixCBFloat16INTEL = 2,
+            MatrixResultBFloat16INTEL = 3,
+            MatrixAPackedInt8INTEL = 4,
+            MatrixBPackedInt8INTEL = 5,
+            MatrixAPackedInt4INTEL = 6,
+            MatrixBPackedInt4INTEL = 7,
+            MatrixATF32INTEL = 8,
+            MatrixBTF32INTEL = 9,
+            MatrixAPackedFloat16INTEL = 10,
+            MatrixBPackedFloat16INTEL = 11,
+            MatrixAPackedBFloat16INTEL = 12,
+            MatrixBPackedBFloat16INTEL = 13,
+            Max = 0x7fffffff,
+        }
+
+        [AllowDuplicates, CRepr] public enum MatrixMultiplyAccumulateOperandsMask
+        {
+            MaskNone = 0,
+            MatrixASignedComponentsINTEL = 0x00000001,
+            MatrixBSignedComponentsINTEL = 0x00000002,
+            MatrixCBFloat16INTEL = 0x00000004,
+            MatrixResultBFloat16INTEL = 0x00000008,
+            MatrixAPackedInt8INTEL = 0x00000010,
+            MatrixBPackedInt8INTEL = 0x00000020,
+            MatrixAPackedInt4INTEL = 0x00000040,
+            MatrixBPackedInt4INTEL = 0x00000080,
+            MatrixATF32INTEL = 0x00000100,
+            MatrixBTF32INTEL = 0x00000200,
+            MatrixAPackedFloat16INTEL = 0x00000400,
+            MatrixBPackedFloat16INTEL = 0x00000800,
+            MatrixAPackedBFloat16INTEL = 0x00001000,
+            MatrixBPackedBFloat16INTEL = 0x00002000,
+        }
+
         [AllowDuplicates, CRepr] public enum RawAccessChainOperandsShift
         {
             RobustnessPerComponentNV = 0,
@@ -1488,6 +1600,35 @@ namespace Spv
             Max = 0x7fffffff,
         }
 
+        [AllowDuplicates, CRepr] public enum CooperativeVectorMatrixLayout
+        {
+            RowMajorNV = 0,
+            ColumnMajorNV = 1,
+            InferencingOptimalNV = 2,
+            TrainingOptimalNV = 3,
+            Max = 0x7fffffff,
+        }
+
+        [AllowDuplicates, CRepr] public enum ComponentType
+        {
+            Float16NV = 0,
+            Float32NV = 1,
+            Float64NV = 2,
+            SignedInt8NV = 3,
+            SignedInt16NV = 4,
+            SignedInt32NV = 5,
+            SignedInt64NV = 6,
+            UnsignedInt8NV = 7,
+            UnsignedInt16NV = 8,
+            UnsignedInt32NV = 9,
+            UnsignedInt64NV = 10,
+            SignedInt8PackedNV = 1000491000,
+            UnsignedInt8PackedNV = 1000491001,
+            FloatE4M3NV = 1000491002,
+            FloatE5M2NV = 1000491003,
+            Max = 0x7fffffff,
+        }
+
         [AllowDuplicates, CRepr] public enum Op
         {
             OpNop = 0,
@@ -1905,9 +2046,14 @@ namespace Spv
             OpFragmentMaskFetchAMD = 5011,
             OpFragmentFetchAMD = 5012,
             OpReadClockKHR = 5056,
-            OpFinalizeNodePayloadsAMDX = 5075,
+            OpAllocateNodePayloadsAMDX = 5074,
+            OpEnqueueNodePayloadsAMDX = 5075,
+            OpTypeNodePayloadArrayAMDX = 5076,
             OpFinishWritingNodePayloadAMDX = 5078,
-            OpInitializeNodePayloadsAMDX = 5090,
+            OpNodePayloadArrayLengthAMDX = 5090,
+            OpIsNodePayloadValidAMDX = 5101,
+            OpConstantStringAMDX = 5103,
+            OpSpecConstantStringAMDX = 5104,
             OpGroupNonUniformQuadAllKHR = 5110,
             OpGroupNonUniformQuadAnyKHR = 5111,
             OpHitObjectRecordHitMotionNV = 5249,
@@ -1944,12 +2090,20 @@ namespace Spv
             OpReorderThreadWithHintNV = 5280,
             OpTypeHitObjectNV = 5281,
             OpImageSampleFootprintNV = 5283,
+            OpTypeCooperativeVectorNV = 5288,
+            OpCooperativeVectorMatrixMulNV = 5289,
+            OpCooperativeVectorOuterProductAccumulateNV = 5290,
+            OpCooperativeVectorReduceSumAccumulateNV = 5291,
+            OpCooperativeVectorMatrixMulAddNV = 5292,
+            OpCooperativeMatrixConvertNV = 5293,
             OpEmitMeshTasksEXT = 5294,
             OpSetMeshOutputsEXT = 5295,
             OpGroupNonUniformPartitionNV = 5296,
             OpWritePackedPrimitiveIndices4x8NV = 5299,
             OpFetchMicroTriangleVertexPositionNV = 5300,
             OpFetchMicroTriangleVertexBarycentricNV = 5301,
+            OpCooperativeVectorLoadNV = 5302,
+            OpCooperativeVectorStoreNV = 5303,
             OpReportIntersectionKHR = 5334,
             OpReportIntersectionNV = 5334,
             OpIgnoreIntersectionNV = 5335,
@@ -1961,6 +2115,8 @@ namespace Spv
             OpTypeAccelerationStructureKHR = 5341,
             OpTypeAccelerationStructureNV = 5341,
             OpExecuteCallableNV = 5344,
+            OpRayQueryGetClusterIdNV = 5345,
+            OpHitObjectGetClusterIdNV = 5346,
             OpTypeCooperativeMatrixNV = 5358,
             OpCooperativeMatrixLoadNV = 5359,
             OpCooperativeMatrixStoreNV = 5360,
@@ -1968,9 +2124,26 @@ namespace Spv
             OpCooperativeMatrixLengthNV = 5362,
             OpBeginInvocationInterlockEXT = 5364,
             OpEndInvocationInterlockEXT = 5365,
+            OpCooperativeMatrixReduceNV = 5366,
+            OpCooperativeMatrixLoadTensorNV = 5367,
+            OpCooperativeMatrixStoreTensorNV = 5368,
+            OpCooperativeMatrixPerElementOpNV = 5369,
+            OpTypeTensorLayoutNV = 5370,
+            OpTypeTensorViewNV = 5371,
+            OpCreateTensorLayoutNV = 5372,
+            OpTensorLayoutSetDimensionNV = 5373,
+            OpTensorLayoutSetStrideNV = 5374,
+            OpTensorLayoutSliceNV = 5375,
+            OpTensorLayoutSetClampValueNV = 5376,
+            OpCreateTensorViewNV = 5377,
+            OpTensorViewSetDimensionNV = 5378,
+            OpTensorViewSetStrideNV = 5379,
             OpDemoteToHelperInvocation = 5380,
             OpDemoteToHelperInvocationEXT = 5380,
             OpIsHelperInvocationEXT = 5381,
+            OpTensorViewSetClipNV = 5382,
+            OpTensorLayoutSetBlockSizeNV = 5384,
+            OpCooperativeMatrixTransposeNV = 5390,
             OpConvertUToImageNV = 5391,
             OpConvertUToSamplerNV = 5392,
             OpConvertImageToUNV = 5393,
@@ -1979,6 +2152,19 @@ namespace Spv
             OpConvertSampledImageToUNV = 5396,
             OpSamplerImageAddressingModeNV = 5397,
             OpRawAccessChainNV = 5398,
+            OpRayQueryGetIntersectionSpherePositionNV = 5427,
+            OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+            OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+            OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+            OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+            OpHitObjectGetSpherePositionNV = 5432,
+            OpHitObjectGetSphereRadiusNV = 5433,
+            OpHitObjectGetLSSPositionsNV = 5434,
+            OpHitObjectGetLSSRadiiNV = 5435,
+            OpHitObjectIsSphereHitNV = 5436,
+            OpHitObjectIsLSSHitNV = 5437,
+            OpRayQueryIsSphereHitNV = 5438,
+            OpRayQueryIsLSSHitNV = 5439,
             OpSubgroupShuffleINTEL = 5571,
             OpSubgroupShuffleDownINTEL = 5572,
             OpSubgroupShuffleUpINTEL = 5573,
@@ -2225,7 +2411,14 @@ namespace Spv
             OpConvertBF16ToFINTEL = 6117,
             OpControlBarrierArriveINTEL = 6142,
             OpControlBarrierWaitINTEL = 6143,
+            OpArithmeticFenceEXT = 6145,
             OpSubgroupBlockPrefetchINTEL = 6221,
+            OpSubgroup2DBlockLoadINTEL = 6231,
+            OpSubgroup2DBlockLoadTransformINTEL = 6232,
+            OpSubgroup2DBlockLoadTransposeINTEL = 6233,
+            OpSubgroup2DBlockPrefetchINTEL = 6234,
+            OpSubgroup2DBlockStoreINTEL = 6235,
+            OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
             OpGroupIMulKHR = 6401,
             OpGroupFMulKHR = 6402,
             OpGroupBitwiseAndKHR = 6403,

include/vulkan/spirv-headers/spirv.cs

@@ -70,6 +70,7 @@ namespace Spv
             WGSL = 10,
             Slang = 11,
             Zig = 12,
+            Rust = 13,
             Max = 0x7fffffff,
         }
 
@@ -174,6 +175,7 @@ namespace Spv
             EarlyAndLateFragmentTestsAMD = 5017,
             StencilRefReplacingEXT = 5027,
             CoalescingAMDX = 5069,
+            IsApiEntryAMDX = 5070,
             MaxNodeRecursionAMDX = 5071,
             StaticNumWorkgroupsAMDX = 5072,
             ShaderIndexAMDX = 5073,
@@ -186,6 +188,7 @@ namespace Spv
             StencilRefLessBackAMD = 5084,
             QuadDerivativesKHR = 5088,
             RequireFullQuadsKHR = 5089,
+            SharesInputWithAMDX = 5102,
             OutputLinesEXT = 5269,
             OutputLinesNV = 5269,
             OutputPrimitivesEXT = 5270,
@@ -240,7 +243,6 @@ namespace Spv
             StorageBuffer = 12,
             TileImageEXT = 4172,
             NodePayloadAMDX = 5068,
-            NodeOutputPayloadAMDX = 5076,
             CallableDataKHR = 5328,
             CallableDataNV = 5328,
             IncomingCallableDataKHR = 5329,
@@ -568,6 +570,10 @@ namespace Spv
             NodeMaxPayloadsAMDX = 5020,
             TrackFinishWritingAMDX = 5078,
             PayloadNodeNameAMDX = 5091,
+            PayloadNodeBaseIndexAMDX = 5098,
+            PayloadNodeSparseArrayAMDX = 5099,
+            PayloadNodeArraySizeAMDX = 5100,
+            PayloadDispatchIndirectAMDX = 5105,
             OverrideCoverageNV = 5248,
             PassthroughNV = 5250,
             ViewportRelativeNV = 5252,
@@ -732,7 +738,7 @@ namespace Spv
             BaryCoordSmoothSampleAMD = 4997,
             BaryCoordPullModelAMD = 4998,
             FragStencilRefEXT = 5014,
-            CoalescedInputCountAMDX = 5021,
+            RemainingRecursionLevelsAMDX = 5021,
             ShaderIndexAMDX = 5073,
             ViewportMaskNV = 5253,
             SecondaryPositionNV = 5257,
@@ -792,12 +798,19 @@ namespace Spv
             IncomingRayFlagsKHR = 5351,
             IncomingRayFlagsNV = 5351,
             RayGeometryIndexKHR = 5352,
+            HitIsSphereNV = 5359,
+            HitIsLSSNV = 5360,
+            HitSpherePositionNV = 5361,
             WarpsPerSMNV = 5374,
             SMCountNV = 5375,
             WarpIDNV = 5376,
             SMIDNV = 5377,
+            HitLSSPositionsNV = 5396,
             HitKindFrontFacingMicroTriangleNV = 5405,
             HitKindBackFacingMicroTriangleNV = 5406,
+            HitSphereRadiusNV = 5420,
+            HitLSSRadiiNV = 5421,
+            ClusterIDNV = 5436,
             CullMaskKHR = 6021,
             Max = 0x7fffffff,
         }
@@ -870,6 +883,7 @@ namespace Spv
             DontInline = 1,
             Pure = 2,
             Const = 3,
+            OptNoneEXT = 16,
             OptNoneINTEL = 16,
             Max = 0x7fffffff,
         }
@@ -881,6 +895,7 @@ namespace Spv
             DontInline = 0x00000002,
             Pure = 0x00000004,
             Const = 0x00000008,
+            OptNoneEXT = 0x00010000,
             OptNoneINTEL = 0x00010000,
         }
 
@@ -1193,9 +1208,20 @@ namespace Spv
             ShaderInvocationReorderNV = 5383,
             BindlessTextureNV = 5390,
             RayQueryPositionFetchKHR = 5391,
+            CooperativeVectorNV = 5394,
             AtomicFloat16VectorNV = 5404,
             RayTracingDisplacementMicromapNV = 5409,
             RawAccessChainsNV = 5414,
+            RayTracingSpheresGeometryNV = 5418,
+            RayTracingLinearSweptSpheresGeometryNV = 5419,
+            CooperativeMatrixReductionsNV = 5430,
+            CooperativeMatrixConversionsNV = 5431,
+            CooperativeMatrixPerElementOperationsNV = 5432,
+            CooperativeMatrixTensorAddressingNV = 5433,
+            CooperativeMatrixBlockLoadsNV = 5434,
+            CooperativeVectorTrainingNV = 5435,
+            RayTracingClusterAccelerationStructureNV = 5437,
+            TensorAddressingNV = 5439,
             SubgroupShuffleINTEL = 5568,
             SubgroupBufferBlockIOINTEL = 5569,
             SubgroupImageBlockIOINTEL = 5570,
@@ -1255,11 +1281,13 @@ namespace Spv
             AtomicFloat32AddEXT = 6033,
             AtomicFloat64AddEXT = 6034,
             LongCompositesINTEL = 6089,
+            OptNoneEXT = 6094,
             OptNoneINTEL = 6094,
             AtomicFloat16AddEXT = 6095,
             DebugInfoModuleINTEL = 6114,
             BFloat16ConversionINTEL = 6115,
             SplitBarrierINTEL = 6141,
+            ArithmeticFenceEXT = 6144,
             FPGAClusterAttributesV2INTEL = 6150,
             FPGAKernelAttributesv2INTEL = 6161,
             FPMaxErrorINTEL = 6169,
@@ -1268,6 +1296,10 @@ namespace Spv
             GlobalVariableHostAccessINTEL = 6187,
             GlobalVariableFPGADecorationsINTEL = 6189,
             SubgroupBufferPrefetchINTEL = 6220,
+            Subgroup2DBlockIOINTEL = 6228,
+            Subgroup2DBlockTransformINTEL = 6229,
+            Subgroup2DBlockTransposeINTEL = 6230,
+            SubgroupMatrixMultiplyAccumulateINTEL = 6236,
             GroupUniformArithmeticKHR = 6400,
             MaskedGatherScatterINTEL = 6427,
             CacheControlsINTEL = 6441,
@@ -1285,6 +1317,7 @@ namespace Spv
             CullFrontFacingTrianglesKHR = 5,
             CullOpaqueKHR = 6,
             CullNoOpaqueKHR = 7,
+            SkipBuiltinPrimitivesNV = 8,
             SkipTrianglesKHR = 8,
             SkipAABBsKHR = 9,
             ForceOpacityMicromap2StateEXT = 10,
@@ -1302,6 +1335,7 @@ namespace Spv
             CullFrontFacingTrianglesKHR = 0x00000020,
             CullOpaqueKHR = 0x00000040,
             CullNoOpaqueKHR = 0x00000080,
+            SkipBuiltinPrimitivesNV = 0x00000100,
             SkipTrianglesKHR = 0x00000100,
             SkipAABBsKHR = 0x00000200,
             ForceOpacityMicromap2StateEXT = 0x00000400,
@@ -1427,6 +1461,46 @@ namespace Spv
             Max = 0x7fffffff,
         }
 
+        public enum CooperativeMatrixReduceShift
+        {
+            Row = 0,
+            Column = 1,
+            CooperativeMatrixReduce2x2 = 2,
+            Max = 0x7fffffff,
+        }
+
+        public enum CooperativeMatrixReduceMask
+        {
+            MaskNone = 0,
+            Row = 0x00000001,
+            Column = 0x00000002,
+            CooperativeMatrixReduce2x2 = 0x00000004,
+        }
+
+        public enum TensorClampMode
+        {
+            Undefined = 0,
+            Constant = 1,
+            ClampToEdge = 2,
+            Repeat = 3,
+            RepeatMirrored = 4,
+            Max = 0x7fffffff,
+        }
+
+        public enum TensorAddressingOperandsShift
+        {
+            TensorView = 0,
+            DecodeFunc = 1,
+            Max = 0x7fffffff,
+        }
+
+        public enum TensorAddressingOperandsMask
+        {
+            MaskNone = 0,
+            TensorView = 0x00000001,
+            DecodeFunc = 0x00000002,
+        }
+
         public enum InitializationModeQualifier
         {
             InitOnDeviceReprogramINTEL = 0,
@@ -1468,6 +1542,44 @@ namespace Spv
             Max = 0x7fffffff,
         }
 
+        public enum MatrixMultiplyAccumulateOperandsShift
+        {
+            MatrixASignedComponentsINTEL = 0,
+            MatrixBSignedComponentsINTEL = 1,
+            MatrixCBFloat16INTEL = 2,
+            MatrixResultBFloat16INTEL = 3,
+            MatrixAPackedInt8INTEL = 4,
+            MatrixBPackedInt8INTEL = 5,
+            MatrixAPackedInt4INTEL = 6,
+            MatrixBPackedInt4INTEL = 7,
+            MatrixATF32INTEL = 8,
+            MatrixBTF32INTEL = 9,
+            MatrixAPackedFloat16INTEL = 10,
+            MatrixBPackedFloat16INTEL = 11,
+            MatrixAPackedBFloat16INTEL = 12,
+            MatrixBPackedBFloat16INTEL = 13,
+            Max = 0x7fffffff,
+        }
+
+        public enum MatrixMultiplyAccumulateOperandsMask
+        {
+            MaskNone = 0,
+            MatrixASignedComponentsINTEL = 0x00000001,
+            MatrixBSignedComponentsINTEL = 0x00000002,
+            MatrixCBFloat16INTEL = 0x00000004,
+            MatrixResultBFloat16INTEL = 0x00000008,
+            MatrixAPackedInt8INTEL = 0x00000010,
+            MatrixBPackedInt8INTEL = 0x00000020,
+            MatrixAPackedInt4INTEL = 0x00000040,
+            MatrixBPackedInt4INTEL = 0x00000080,
+            MatrixATF32INTEL = 0x00000100,
+            MatrixBTF32INTEL = 0x00000200,
+            MatrixAPackedFloat16INTEL = 0x00000400,
+            MatrixBPackedFloat16INTEL = 0x00000800,
+            MatrixAPackedBFloat16INTEL = 0x00001000,
+            MatrixBPackedBFloat16INTEL = 0x00002000,
+        }
+
         public enum RawAccessChainOperandsShift
         {
             RobustnessPerComponentNV = 0,
@@ -1487,6 +1599,35 @@ namespace Spv
             Max = 0x7fffffff,
         }
 
+        public enum CooperativeVectorMatrixLayout
+        {
+            RowMajorNV = 0,
+            ColumnMajorNV = 1,
+            InferencingOptimalNV = 2,
+            TrainingOptimalNV = 3,
+            Max = 0x7fffffff,
+        }
+
+        public enum ComponentType
+        {
+            Float16NV = 0,
+            Float32NV = 1,
+            Float64NV = 2,
+            SignedInt8NV = 3,
+            SignedInt16NV = 4,
+            SignedInt32NV = 5,
+            SignedInt64NV = 6,
+            UnsignedInt8NV = 7,
+            UnsignedInt16NV = 8,
+            UnsignedInt32NV = 9,
+            UnsignedInt64NV = 10,
+            SignedInt8PackedNV = 1000491000,
+            UnsignedInt8PackedNV = 1000491001,
+            FloatE4M3NV = 1000491002,
+            FloatE5M2NV = 1000491003,
+            Max = 0x7fffffff,
+        }
+
         public enum Op
         {
             OpNop = 0,
@@ -1904,9 +2045,14 @@ namespace Spv
             OpFragmentMaskFetchAMD = 5011,
             OpFragmentFetchAMD = 5012,
             OpReadClockKHR = 5056,
-            OpFinalizeNodePayloadsAMDX = 5075,
+            OpAllocateNodePayloadsAMDX = 5074,
+            OpEnqueueNodePayloadsAMDX = 5075,
+            OpTypeNodePayloadArrayAMDX = 5076,
             OpFinishWritingNodePayloadAMDX = 5078,
-            OpInitializeNodePayloadsAMDX = 5090,
+            OpNodePayloadArrayLengthAMDX = 5090,
+            OpIsNodePayloadValidAMDX = 5101,
+            OpConstantStringAMDX = 5103,
+            OpSpecConstantStringAMDX = 5104,
             OpGroupNonUniformQuadAllKHR = 5110,
             OpGroupNonUniformQuadAnyKHR = 5111,
             OpHitObjectRecordHitMotionNV = 5249,
@@ -1943,12 +2089,20 @@ namespace Spv
             OpReorderThreadWithHintNV = 5280,
             OpTypeHitObjectNV = 5281,
             OpImageSampleFootprintNV = 5283,
+            OpTypeCooperativeVectorNV = 5288,
+            OpCooperativeVectorMatrixMulNV = 5289,
+            OpCooperativeVectorOuterProductAccumulateNV = 5290,
+            OpCooperativeVectorReduceSumAccumulateNV = 5291,
+            OpCooperativeVectorMatrixMulAddNV = 5292,
+            OpCooperativeMatrixConvertNV = 5293,
             OpEmitMeshTasksEXT = 5294,
             OpSetMeshOutputsEXT = 5295,
             OpGroupNonUniformPartitionNV = 5296,
             OpWritePackedPrimitiveIndices4x8NV = 5299,
             OpFetchMicroTriangleVertexPositionNV = 5300,
             OpFetchMicroTriangleVertexBarycentricNV = 5301,
+            OpCooperativeVectorLoadNV = 5302,
+            OpCooperativeVectorStoreNV = 5303,
             OpReportIntersectionKHR = 5334,
             OpReportIntersectionNV = 5334,
             OpIgnoreIntersectionNV = 5335,
@@ -1960,6 +2114,8 @@ namespace Spv
             OpTypeAccelerationStructureKHR = 5341,
             OpTypeAccelerationStructureNV = 5341,
             OpExecuteCallableNV = 5344,
+            OpRayQueryGetClusterIdNV = 5345,
+            OpHitObjectGetClusterIdNV = 5346,
             OpTypeCooperativeMatrixNV = 5358,
             OpCooperativeMatrixLoadNV = 5359,
             OpCooperativeMatrixStoreNV = 5360,
@@ -1967,9 +2123,26 @@ namespace Spv
             OpCooperativeMatrixLengthNV = 5362,
             OpBeginInvocationInterlockEXT = 5364,
             OpEndInvocationInterlockEXT = 5365,
+            OpCooperativeMatrixReduceNV = 5366,
+            OpCooperativeMatrixLoadTensorNV = 5367,
+            OpCooperativeMatrixStoreTensorNV = 5368,
+            OpCooperativeMatrixPerElementOpNV = 5369,
+            OpTypeTensorLayoutNV = 5370,
+            OpTypeTensorViewNV = 5371,
+            OpCreateTensorLayoutNV = 5372,
+            OpTensorLayoutSetDimensionNV = 5373,
+            OpTensorLayoutSetStrideNV = 5374,
+            OpTensorLayoutSliceNV = 5375,
+            OpTensorLayoutSetClampValueNV = 5376,
+            OpCreateTensorViewNV = 5377,
+            OpTensorViewSetDimensionNV = 5378,
+            OpTensorViewSetStrideNV = 5379,
             OpDemoteToHelperInvocation = 5380,
             OpDemoteToHelperInvocationEXT = 5380,
             OpIsHelperInvocationEXT = 5381,
+            OpTensorViewSetClipNV = 5382,
+            OpTensorLayoutSetBlockSizeNV = 5384,
+            OpCooperativeMatrixTransposeNV = 5390,
             OpConvertUToImageNV = 5391,
             OpConvertUToSamplerNV = 5392,
             OpConvertImageToUNV = 5393,
@@ -1978,6 +2151,19 @@ namespace Spv
             OpConvertSampledImageToUNV = 5396,
             OpSamplerImageAddressingModeNV = 5397,
             OpRawAccessChainNV = 5398,
+            OpRayQueryGetIntersectionSpherePositionNV = 5427,
+            OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+            OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+            OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+            OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+            OpHitObjectGetSpherePositionNV = 5432,
+            OpHitObjectGetSphereRadiusNV = 5433,
+            OpHitObjectGetLSSPositionsNV = 5434,
+            OpHitObjectGetLSSRadiiNV = 5435,
+            OpHitObjectIsSphereHitNV = 5436,
+            OpHitObjectIsLSSHitNV = 5437,
+            OpRayQueryIsSphereHitNV = 5438,
+            OpRayQueryIsLSSHitNV = 5439,
             OpSubgroupShuffleINTEL = 5571,
             OpSubgroupShuffleDownINTEL = 5572,
             OpSubgroupShuffleUpINTEL = 5573,
@@ -2224,7 +2410,14 @@ namespace Spv
             OpConvertBF16ToFINTEL = 6117,
             OpControlBarrierArriveINTEL = 6142,
             OpControlBarrierWaitINTEL = 6143,
+            OpArithmeticFenceEXT = 6145,
             OpSubgroupBlockPrefetchINTEL = 6221,
+            OpSubgroup2DBlockLoadINTEL = 6231,
+            OpSubgroup2DBlockLoadTransformINTEL = 6232,
+            OpSubgroup2DBlockLoadTransposeINTEL = 6233,
+            OpSubgroup2DBlockPrefetchINTEL = 6234,
+            OpSubgroup2DBlockStoreINTEL = 6235,
+            OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
             OpGroupIMulKHR = 6401,
             OpGroupFMulKHR = 6402,
             OpGroupBitwiseAndKHR = 6403,

include/vulkan/spirv-headers/spirv.h

@@ -78,6 +78,7 @@ typedef enum SpvSourceLanguage_ {
     SpvSourceLanguageWGSL = 10,
     SpvSourceLanguageSlang = 11,
     SpvSourceLanguageZig = 12,
+    SpvSourceLanguageRust = 13,
     SpvSourceLanguageMax = 0x7fffffff,
 } SpvSourceLanguage;
 
@@ -178,6 +179,7 @@ typedef enum SpvExecutionMode_ {
     SpvExecutionModeEarlyAndLateFragmentTestsAMD = 5017,
     SpvExecutionModeStencilRefReplacingEXT = 5027,
     SpvExecutionModeCoalescingAMDX = 5069,
+    SpvExecutionModeIsApiEntryAMDX = 5070,
     SpvExecutionModeMaxNodeRecursionAMDX = 5071,
     SpvExecutionModeStaticNumWorkgroupsAMDX = 5072,
     SpvExecutionModeShaderIndexAMDX = 5073,
@@ -190,6 +192,7 @@ typedef enum SpvExecutionMode_ {
     SpvExecutionModeStencilRefLessBackAMD = 5084,
     SpvExecutionModeQuadDerivativesKHR = 5088,
     SpvExecutionModeRequireFullQuadsKHR = 5089,
+    SpvExecutionModeSharesInputWithAMDX = 5102,
     SpvExecutionModeOutputLinesEXT = 5269,
     SpvExecutionModeOutputLinesNV = 5269,
     SpvExecutionModeOutputPrimitivesEXT = 5270,
@@ -243,7 +246,6 @@ typedef enum SpvStorageClass_ {
     SpvStorageClassStorageBuffer = 12,
     SpvStorageClassTileImageEXT = 4172,
     SpvStorageClassNodePayloadAMDX = 5068,
-    SpvStorageClassNodeOutputPayloadAMDX = 5076,
     SpvStorageClassCallableDataKHR = 5328,
     SpvStorageClassCallableDataNV = 5328,
     SpvStorageClassIncomingCallableDataKHR = 5329,
@@ -556,6 +558,10 @@ typedef enum SpvDecoration_ {
     SpvDecorationNodeMaxPayloadsAMDX = 5020,
     SpvDecorationTrackFinishWritingAMDX = 5078,
     SpvDecorationPayloadNodeNameAMDX = 5091,
+    SpvDecorationPayloadNodeBaseIndexAMDX = 5098,
+    SpvDecorationPayloadNodeSparseArrayAMDX = 5099,
+    SpvDecorationPayloadNodeArraySizeAMDX = 5100,
+    SpvDecorationPayloadDispatchIndirectAMDX = 5105,
     SpvDecorationOverrideCoverageNV = 5248,
     SpvDecorationPassthroughNV = 5250,
     SpvDecorationViewportRelativeNV = 5252,
@@ -719,7 +725,7 @@ typedef enum SpvBuiltIn_ {
     SpvBuiltInBaryCoordSmoothSampleAMD = 4997,
     SpvBuiltInBaryCoordPullModelAMD = 4998,
     SpvBuiltInFragStencilRefEXT = 5014,
-    SpvBuiltInCoalescedInputCountAMDX = 5021,
+    SpvBuiltInRemainingRecursionLevelsAMDX = 5021,
     SpvBuiltInShaderIndexAMDX = 5073,
     SpvBuiltInViewportMaskNV = 5253,
     SpvBuiltInSecondaryPositionNV = 5257,
@@ -779,12 +785,19 @@ typedef enum SpvBuiltIn_ {
     SpvBuiltInIncomingRayFlagsKHR = 5351,
     SpvBuiltInIncomingRayFlagsNV = 5351,
     SpvBuiltInRayGeometryIndexKHR = 5352,
+    SpvBuiltInHitIsSphereNV = 5359,
+    SpvBuiltInHitIsLSSNV = 5360,
+    SpvBuiltInHitSpherePositionNV = 5361,
     SpvBuiltInWarpsPerSMNV = 5374,
     SpvBuiltInSMCountNV = 5375,
     SpvBuiltInWarpIDNV = 5376,
     SpvBuiltInSMIDNV = 5377,
+    SpvBuiltInHitLSSPositionsNV = 5396,
     SpvBuiltInHitKindFrontFacingMicroTriangleNV = 5405,
     SpvBuiltInHitKindBackFacingMicroTriangleNV = 5406,
+    SpvBuiltInHitSphereRadiusNV = 5420,
+    SpvBuiltInHitLSSRadiiNV = 5421,
+    SpvBuiltInClusterIDNV = 5436,
     SpvBuiltInCullMaskKHR = 6021,
     SpvBuiltInMax = 0x7fffffff,
 } SpvBuiltIn;
@@ -852,6 +865,7 @@ typedef enum SpvFunctionControlShift_ {
     SpvFunctionControlDontInlineShift = 1,
     SpvFunctionControlPureShift = 2,
     SpvFunctionControlConstShift = 3,
+    SpvFunctionControlOptNoneEXTShift = 16,
     SpvFunctionControlOptNoneINTELShift = 16,
     SpvFunctionControlMax = 0x7fffffff,
 } SpvFunctionControlShift;
@@ -862,6 +876,7 @@ typedef enum SpvFunctionControlMask_ {
     SpvFunctionControlDontInlineMask = 0x00000002,
     SpvFunctionControlPureMask = 0x00000004,
     SpvFunctionControlConstMask = 0x00000008,
+    SpvFunctionControlOptNoneEXTMask = 0x00010000,
     SpvFunctionControlOptNoneINTELMask = 0x00010000,
 } SpvFunctionControlMask;
 
@@ -1164,9 +1179,20 @@ typedef enum SpvCapability_ {
     SpvCapabilityShaderInvocationReorderNV = 5383,
     SpvCapabilityBindlessTextureNV = 5390,
     SpvCapabilityRayQueryPositionFetchKHR = 5391,
+    SpvCapabilityCooperativeVectorNV = 5394,
     SpvCapabilityAtomicFloat16VectorNV = 5404,
     SpvCapabilityRayTracingDisplacementMicromapNV = 5409,
     SpvCapabilityRawAccessChainsNV = 5414,
+    SpvCapabilityRayTracingSpheresGeometryNV = 5418,
+    SpvCapabilityRayTracingLinearSweptSpheresGeometryNV = 5419,
+    SpvCapabilityCooperativeMatrixReductionsNV = 5430,
+    SpvCapabilityCooperativeMatrixConversionsNV = 5431,
+    SpvCapabilityCooperativeMatrixPerElementOperationsNV = 5432,
+    SpvCapabilityCooperativeMatrixTensorAddressingNV = 5433,
+    SpvCapabilityCooperativeMatrixBlockLoadsNV = 5434,
+    SpvCapabilityCooperativeVectorTrainingNV = 5435,
+    SpvCapabilityRayTracingClusterAccelerationStructureNV = 5437,
+    SpvCapabilityTensorAddressingNV = 5439,
     SpvCapabilitySubgroupShuffleINTEL = 5568,
     SpvCapabilitySubgroupBufferBlockIOINTEL = 5569,
     SpvCapabilitySubgroupImageBlockIOINTEL = 5570,
@@ -1226,11 +1252,13 @@ typedef enum SpvCapability_ {
     SpvCapabilityAtomicFloat32AddEXT = 6033,
     SpvCapabilityAtomicFloat64AddEXT = 6034,
     SpvCapabilityLongCompositesINTEL = 6089,
+    SpvCapabilityOptNoneEXT = 6094,
     SpvCapabilityOptNoneINTEL = 6094,
     SpvCapabilityAtomicFloat16AddEXT = 6095,
     SpvCapabilityDebugInfoModuleINTEL = 6114,
     SpvCapabilityBFloat16ConversionINTEL = 6115,
     SpvCapabilitySplitBarrierINTEL = 6141,
+    SpvCapabilityArithmeticFenceEXT = 6144,
     SpvCapabilityFPGAClusterAttributesV2INTEL = 6150,
     SpvCapabilityFPGAKernelAttributesv2INTEL = 6161,
     SpvCapabilityFPMaxErrorINTEL = 6169,
@@ -1239,6 +1267,10 @@ typedef enum SpvCapability_ {
     SpvCapabilityGlobalVariableHostAccessINTEL = 6187,
     SpvCapabilityGlobalVariableFPGADecorationsINTEL = 6189,
     SpvCapabilitySubgroupBufferPrefetchINTEL = 6220,
+    SpvCapabilitySubgroup2DBlockIOINTEL = 6228,
+    SpvCapabilitySubgroup2DBlockTransformINTEL = 6229,
+    SpvCapabilitySubgroup2DBlockTransposeINTEL = 6230,
+    SpvCapabilitySubgroupMatrixMultiplyAccumulateINTEL = 6236,
     SpvCapabilityGroupUniformArithmeticKHR = 6400,
     SpvCapabilityMaskedGatherScatterINTEL = 6427,
     SpvCapabilityCacheControlsINTEL = 6441,
@@ -1255,6 +1287,7 @@ typedef enum SpvRayFlagsShift_ {
     SpvRayFlagsCullFrontFacingTrianglesKHRShift = 5,
     SpvRayFlagsCullOpaqueKHRShift = 6,
     SpvRayFlagsCullNoOpaqueKHRShift = 7,
+    SpvRayFlagsSkipBuiltinPrimitivesNVShift = 8,
     SpvRayFlagsSkipTrianglesKHRShift = 8,
     SpvRayFlagsSkipAABBsKHRShift = 9,
     SpvRayFlagsForceOpacityMicromap2StateEXTShift = 10,
@@ -1271,6 +1304,7 @@ typedef enum SpvRayFlagsMask_ {
     SpvRayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
     SpvRayFlagsCullOpaqueKHRMask = 0x00000040,
     SpvRayFlagsCullNoOpaqueKHRMask = 0x00000080,
+    SpvRayFlagsSkipBuiltinPrimitivesNVMask = 0x00000100,
     SpvRayFlagsSkipTrianglesKHRMask = 0x00000100,
     SpvRayFlagsSkipAABBsKHRMask = 0x00000200,
     SpvRayFlagsForceOpacityMicromap2StateEXTMask = 0x00000400,
@@ -1382,6 +1416,41 @@ typedef enum SpvCooperativeMatrixUse_ {
     SpvCooperativeMatrixUseMax = 0x7fffffff,
 } SpvCooperativeMatrixUse;
 
+typedef enum SpvCooperativeMatrixReduceShift_ {
+    SpvCooperativeMatrixReduceRowShift = 0,
+    SpvCooperativeMatrixReduceColumnShift = 1,
+    SpvCooperativeMatrixReduce2x2Shift = 2,
+    SpvCooperativeMatrixReduceMax = 0x7fffffff,
+} SpvCooperativeMatrixReduceShift;
+
+typedef enum SpvCooperativeMatrixReduceMask_ {
+    SpvCooperativeMatrixReduceMaskNone = 0,
+    SpvCooperativeMatrixReduceRowMask = 0x00000001,
+    SpvCooperativeMatrixReduceColumnMask = 0x00000002,
+    SpvCooperativeMatrixReduce2x2Mask = 0x00000004,
+} SpvCooperativeMatrixReduceMask;
+
+typedef enum SpvTensorClampMode_ {
+    SpvTensorClampModeUndefined = 0,
+    SpvTensorClampModeConstant = 1,
+    SpvTensorClampModeClampToEdge = 2,
+    SpvTensorClampModeRepeat = 3,
+    SpvTensorClampModeRepeatMirrored = 4,
+    SpvTensorClampModeMax = 0x7fffffff,
+} SpvTensorClampMode;
+
+typedef enum SpvTensorAddressingOperandsShift_ {
+    SpvTensorAddressingOperandsTensorViewShift = 0,
+    SpvTensorAddressingOperandsDecodeFuncShift = 1,
+    SpvTensorAddressingOperandsMax = 0x7fffffff,
+} SpvTensorAddressingOperandsShift;
+
+typedef enum SpvTensorAddressingOperandsMask_ {
+    SpvTensorAddressingOperandsMaskNone = 0,
+    SpvTensorAddressingOperandsTensorViewMask = 0x00000001,
+    SpvTensorAddressingOperandsDecodeFuncMask = 0x00000002,
+} SpvTensorAddressingOperandsMask;
+
 typedef enum SpvInitializationModeQualifier_ {
     SpvInitializationModeQualifierInitOnDeviceReprogramINTEL = 0,
     SpvInitializationModeQualifierInitOnDeviceResetINTEL = 1,
@@ -1418,6 +1487,42 @@ typedef enum SpvNamedMaximumNumberOfRegisters_ {
     SpvNamedMaximumNumberOfRegistersMax = 0x7fffffff,
 } SpvNamedMaximumNumberOfRegisters;
 
+typedef enum SpvMatrixMultiplyAccumulateOperandsShift_ {
+    SpvMatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELShift = 0,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELShift = 1,
+    SpvMatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELShift = 2,
+    SpvMatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELShift = 3,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELShift = 4,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELShift = 5,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELShift = 6,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELShift = 7,
+    SpvMatrixMultiplyAccumulateOperandsMatrixATF32INTELShift = 8,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBTF32INTELShift = 9,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELShift = 10,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELShift = 11,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELShift = 12,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELShift = 13,
+    SpvMatrixMultiplyAccumulateOperandsMax = 0x7fffffff,
+} SpvMatrixMultiplyAccumulateOperandsShift;
+
+typedef enum SpvMatrixMultiplyAccumulateOperandsMask_ {
+    SpvMatrixMultiplyAccumulateOperandsMaskNone = 0,
+    SpvMatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELMask = 0x00000001,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELMask = 0x00000002,
+    SpvMatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELMask = 0x00000004,
+    SpvMatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELMask = 0x00000008,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELMask = 0x00000010,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELMask = 0x00000020,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELMask = 0x00000040,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELMask = 0x00000080,
+    SpvMatrixMultiplyAccumulateOperandsMatrixATF32INTELMask = 0x00000100,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBTF32INTELMask = 0x00000200,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELMask = 0x00000400,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELMask = 0x00000800,
+    SpvMatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELMask = 0x00001000,
+    SpvMatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELMask = 0x00002000,
+} SpvMatrixMultiplyAccumulateOperandsMask;
+
 typedef enum SpvRawAccessChainOperandsShift_ {
     SpvRawAccessChainOperandsRobustnessPerComponentNVShift = 0,
     SpvRawAccessChainOperandsRobustnessPerElementNVShift = 1,
@@ -1434,6 +1539,33 @@ typedef enum SpvFPEncoding_ {
     SpvFPEncodingMax = 0x7fffffff,
 } SpvFPEncoding;
 
+typedef enum SpvCooperativeVectorMatrixLayout_ {
+    SpvCooperativeVectorMatrixLayoutRowMajorNV = 0,
+    SpvCooperativeVectorMatrixLayoutColumnMajorNV = 1,
+    SpvCooperativeVectorMatrixLayoutInferencingOptimalNV = 2,
+    SpvCooperativeVectorMatrixLayoutTrainingOptimalNV = 3,
+    SpvCooperativeVectorMatrixLayoutMax = 0x7fffffff,
+} SpvCooperativeVectorMatrixLayout;
+
+typedef enum SpvComponentType_ {
+    SpvComponentTypeFloat16NV = 0,
+    SpvComponentTypeFloat32NV = 1,
+    SpvComponentTypeFloat64NV = 2,
+    SpvComponentTypeSignedInt8NV = 3,
+    SpvComponentTypeSignedInt16NV = 4,
+    SpvComponentTypeSignedInt32NV = 5,
+    SpvComponentTypeSignedInt64NV = 6,
+    SpvComponentTypeUnsignedInt8NV = 7,
+    SpvComponentTypeUnsignedInt16NV = 8,
+    SpvComponentTypeUnsignedInt32NV = 9,
+    SpvComponentTypeUnsignedInt64NV = 10,
+    SpvComponentTypeSignedInt8PackedNV = 1000491000,
+    SpvComponentTypeUnsignedInt8PackedNV = 1000491001,
+    SpvComponentTypeFloatE4M3NV = 1000491002,
+    SpvComponentTypeFloatE5M2NV = 1000491003,
+    SpvComponentTypeMax = 0x7fffffff,
+} SpvComponentType;
+
 typedef enum SpvOp_ {
     SpvOpNop = 0,
     SpvOpUndef = 1,
@@ -1850,9 +1982,14 @@ typedef enum SpvOp_ {
     SpvOpFragmentMaskFetchAMD = 5011,
     SpvOpFragmentFetchAMD = 5012,
     SpvOpReadClockKHR = 5056,
-    SpvOpFinalizeNodePayloadsAMDX = 5075,
+    SpvOpAllocateNodePayloadsAMDX = 5074,
+    SpvOpEnqueueNodePayloadsAMDX = 5075,
+    SpvOpTypeNodePayloadArrayAMDX = 5076,
     SpvOpFinishWritingNodePayloadAMDX = 5078,
-    SpvOpInitializeNodePayloadsAMDX = 5090,
+    SpvOpNodePayloadArrayLengthAMDX = 5090,
+    SpvOpIsNodePayloadValidAMDX = 5101,
+    SpvOpConstantStringAMDX = 5103,
+    SpvOpSpecConstantStringAMDX = 5104,
     SpvOpGroupNonUniformQuadAllKHR = 5110,
     SpvOpGroupNonUniformQuadAnyKHR = 5111,
     SpvOpHitObjectRecordHitMotionNV = 5249,
@@ -1889,12 +2026,20 @@ typedef enum SpvOp_ {
     SpvOpReorderThreadWithHintNV = 5280,
     SpvOpTypeHitObjectNV = 5281,
     SpvOpImageSampleFootprintNV = 5283,
+    SpvOpTypeCooperativeVectorNV = 5288,
+    SpvOpCooperativeVectorMatrixMulNV = 5289,
+    SpvOpCooperativeVectorOuterProductAccumulateNV = 5290,
+    SpvOpCooperativeVectorReduceSumAccumulateNV = 5291,
+    SpvOpCooperativeVectorMatrixMulAddNV = 5292,
+    SpvOpCooperativeMatrixConvertNV = 5293,
     SpvOpEmitMeshTasksEXT = 5294,
     SpvOpSetMeshOutputsEXT = 5295,
     SpvOpGroupNonUniformPartitionNV = 5296,
     SpvOpWritePackedPrimitiveIndices4x8NV = 5299,
     SpvOpFetchMicroTriangleVertexPositionNV = 5300,
     SpvOpFetchMicroTriangleVertexBarycentricNV = 5301,
+    SpvOpCooperativeVectorLoadNV = 5302,
+    SpvOpCooperativeVectorStoreNV = 5303,
     SpvOpReportIntersectionKHR = 5334,
     SpvOpReportIntersectionNV = 5334,
     SpvOpIgnoreIntersectionNV = 5335,
@@ -1906,6 +2051,8 @@ typedef enum SpvOp_ {
     SpvOpTypeAccelerationStructureKHR = 5341,
     SpvOpTypeAccelerationStructureNV = 5341,
     SpvOpExecuteCallableNV = 5344,
+    SpvOpRayQueryGetClusterIdNV = 5345,
+    SpvOpHitObjectGetClusterIdNV = 5346,
     SpvOpTypeCooperativeMatrixNV = 5358,
     SpvOpCooperativeMatrixLoadNV = 5359,
     SpvOpCooperativeMatrixStoreNV = 5360,
@@ -1913,9 +2060,26 @@ typedef enum SpvOp_ {
     SpvOpCooperativeMatrixLengthNV = 5362,
     SpvOpBeginInvocationInterlockEXT = 5364,
     SpvOpEndInvocationInterlockEXT = 5365,
+    SpvOpCooperativeMatrixReduceNV = 5366,
+    SpvOpCooperativeMatrixLoadTensorNV = 5367,
+    SpvOpCooperativeMatrixStoreTensorNV = 5368,
+    SpvOpCooperativeMatrixPerElementOpNV = 5369,
+    SpvOpTypeTensorLayoutNV = 5370,
+    SpvOpTypeTensorViewNV = 5371,
+    SpvOpCreateTensorLayoutNV = 5372,
+    SpvOpTensorLayoutSetDimensionNV = 5373,
+    SpvOpTensorLayoutSetStrideNV = 5374,
+    SpvOpTensorLayoutSliceNV = 5375,
+    SpvOpTensorLayoutSetClampValueNV = 5376,
+    SpvOpCreateTensorViewNV = 5377,
+    SpvOpTensorViewSetDimensionNV = 5378,
+    SpvOpTensorViewSetStrideNV = 5379,
     SpvOpDemoteToHelperInvocation = 5380,
     SpvOpDemoteToHelperInvocationEXT = 5380,
     SpvOpIsHelperInvocationEXT = 5381,
+    SpvOpTensorViewSetClipNV = 5382,
+    SpvOpTensorLayoutSetBlockSizeNV = 5384,
+    SpvOpCooperativeMatrixTransposeNV = 5390,
     SpvOpConvertUToImageNV = 5391,
     SpvOpConvertUToSamplerNV = 5392,
     SpvOpConvertImageToUNV = 5393,
@@ -1924,6 +2088,19 @@ typedef enum SpvOp_ {
     SpvOpConvertSampledImageToUNV = 5396,
     SpvOpSamplerImageAddressingModeNV = 5397,
     SpvOpRawAccessChainNV = 5398,
+    SpvOpRayQueryGetIntersectionSpherePositionNV = 5427,
+    SpvOpRayQueryGetIntersectionSphereRadiusNV = 5428,
+    SpvOpRayQueryGetIntersectionLSSPositionsNV = 5429,
+    SpvOpRayQueryGetIntersectionLSSRadiiNV = 5430,
+    SpvOpRayQueryGetIntersectionLSSHitValueNV = 5431,
+    SpvOpHitObjectGetSpherePositionNV = 5432,
+    SpvOpHitObjectGetSphereRadiusNV = 5433,
+    SpvOpHitObjectGetLSSPositionsNV = 5434,
+    SpvOpHitObjectGetLSSRadiiNV = 5435,
+    SpvOpHitObjectIsSphereHitNV = 5436,
+    SpvOpHitObjectIsLSSHitNV = 5437,
+    SpvOpRayQueryIsSphereHitNV = 5438,
+    SpvOpRayQueryIsLSSHitNV = 5439,
     SpvOpSubgroupShuffleINTEL = 5571,
     SpvOpSubgroupShuffleDownINTEL = 5572,
     SpvOpSubgroupShuffleUpINTEL = 5573,
@@ -2170,7 +2347,14 @@ typedef enum SpvOp_ {
     SpvOpConvertBF16ToFINTEL = 6117,
     SpvOpControlBarrierArriveINTEL = 6142,
     SpvOpControlBarrierWaitINTEL = 6143,
+    SpvOpArithmeticFenceEXT = 6145,
     SpvOpSubgroupBlockPrefetchINTEL = 6221,
+    SpvOpSubgroup2DBlockLoadINTEL = 6231,
+    SpvOpSubgroup2DBlockLoadTransformINTEL = 6232,
+    SpvOpSubgroup2DBlockLoadTransposeINTEL = 6233,
+    SpvOpSubgroup2DBlockPrefetchINTEL = 6234,
+    SpvOpSubgroup2DBlockStoreINTEL = 6235,
+    SpvOpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
     SpvOpGroupIMulKHR = 6401,
     SpvOpGroupFMulKHR = 6402,
     SpvOpGroupBitwiseAndKHR = 6403,
@@ -2601,9 +2785,14 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
     case SpvOpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
     case SpvOpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
     case SpvOpReadClockKHR: *hasResult = true; *hasResultType = true; break;
-    case SpvOpFinalizeNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case SpvOpAllocateNodePayloadsAMDX: *hasResult = true; *hasResultType = true; break;
+    case SpvOpEnqueueNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case SpvOpTypeNodePayloadArrayAMDX: *hasResult = true; *hasResultType = false; break;
     case SpvOpFinishWritingNodePayloadAMDX: *hasResult = true; *hasResultType = true; break;
-    case SpvOpInitializeNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case SpvOpNodePayloadArrayLengthAMDX: *hasResult = true; *hasResultType = true; break;
+    case SpvOpIsNodePayloadValidAMDX: *hasResult = true; *hasResultType = true; break;
+    case SpvOpConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
+    case SpvOpSpecConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
     case SpvOpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break;
     case SpvOpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break;
     case SpvOpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
@@ -2640,12 +2829,20 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
     case SpvOpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
     case SpvOpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
     case SpvOpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTypeCooperativeVectorNV: *hasResult = true; *hasResultType = false; break;
+    case SpvOpCooperativeVectorMatrixMulNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeVectorOuterProductAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCooperativeVectorReduceSumAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCooperativeVectorMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeMatrixConvertNV: *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 SpvOpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break;
     case SpvOpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeVectorLoadNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeVectorStoreNV: *hasResult = false; *hasResultType = false; break;
     case SpvOpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break;
     case SpvOpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
     case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
@@ -2655,6 +2852,8 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
     case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
     case SpvOpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break;
     case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpRayQueryGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
     case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
     case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
     case SpvOpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
@@ -2662,8 +2861,25 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
     case SpvOpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
     case SpvOpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
     case SpvOpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCooperativeMatrixReduceNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeMatrixLoadTensorNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeMatrixStoreTensorNV: *hasResult = false; *hasResultType = false; break;
+    case SpvOpCooperativeMatrixPerElementOpNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTypeTensorLayoutNV: *hasResult = true; *hasResultType = false; break;
+    case SpvOpTypeTensorViewNV: *hasResult = true; *hasResultType = false; break;
+    case SpvOpCreateTensorLayoutNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorLayoutSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorLayoutSetStrideNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorLayoutSliceNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorLayoutSetClampValueNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCreateTensorViewNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorViewSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorViewSetStrideNV: *hasResult = true; *hasResultType = true; break;
     case SpvOpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
     case SpvOpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorViewSetClipNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpTensorLayoutSetBlockSizeNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpCooperativeMatrixTransposeNV: *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;
@@ -2672,6 +2888,19 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
     case SpvOpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
     case SpvOpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;
     case SpvOpRawAccessChainNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryGetIntersectionLSSHitValueNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpHitObjectGetSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpHitObjectGetSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpHitObjectGetLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpHitObjectGetLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpHitObjectIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpHitObjectIsLSSHitNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case SpvOpRayQueryIsLSSHitNV: *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;
@@ -2698,7 +2927,7 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
     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 SpvOpAsmTargetINTEL: *hasResult = true; *hasResultType = false; break;
     case SpvOpAsmINTEL: *hasResult = true; *hasResultType = true; break;
     case SpvOpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
     case SpvOpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
@@ -2916,7 +3145,14 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
     case SpvOpConvertBF16ToFINTEL: *hasResult = true; *hasResultType = true; break;
     case SpvOpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
     case SpvOpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpArithmeticFenceEXT: *hasResult = true; *hasResultType = true; break;
     case SpvOpSubgroupBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroup2DBlockLoadINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroup2DBlockLoadTransformINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroup2DBlockLoadTransposeINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroup2DBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroup2DBlockStoreINTEL: *hasResult = false; *hasResultType = false; break;
+    case SpvOpSubgroupMatrixMultiplyAccumulateINTEL: *hasResult = true; *hasResultType = true; break;
     case SpvOpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
     case SpvOpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
     case SpvOpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
@@ -2944,6 +3180,7 @@ inline const char* SpvSourceLanguageToString(SpvSourceLanguage value) {
     case SpvSourceLanguageWGSL: return "WGSL";
     case SpvSourceLanguageSlang: return "Slang";
     case SpvSourceLanguageZig: return "Zig";
+    case SpvSourceLanguageRust: return "Rust";
     default: return "Unknown";
     }
 }
@@ -3044,6 +3281,7 @@ inline const char* SpvExecutionModeToString(SpvExecutionMode value) {
     case SpvExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD";
     case SpvExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT";
     case SpvExecutionModeCoalescingAMDX: return "CoalescingAMDX";
+    case SpvExecutionModeIsApiEntryAMDX: return "IsApiEntryAMDX";
     case SpvExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX";
     case SpvExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX";
     case SpvExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX";
@@ -3056,6 +3294,7 @@ inline const char* SpvExecutionModeToString(SpvExecutionMode value) {
     case SpvExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD";
     case SpvExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR";
     case SpvExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR";
+    case SpvExecutionModeSharesInputWithAMDX: return "SharesInputWithAMDX";
     case SpvExecutionModeOutputLinesEXT: return "OutputLinesEXT";
     case SpvExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT";
     case SpvExecutionModeDerivativeGroupQuadsKHR: return "DerivativeGroupQuadsKHR";
@@ -3106,7 +3345,6 @@ inline const char* SpvStorageClassToString(SpvStorageClass value) {
     case SpvStorageClassStorageBuffer: return "StorageBuffer";
     case SpvStorageClassTileImageEXT: return "TileImageEXT";
     case SpvStorageClassNodePayloadAMDX: return "NodePayloadAMDX";
-    case SpvStorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX";
     case SpvStorageClassCallableDataKHR: return "CallableDataKHR";
     case SpvStorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR";
     case SpvStorageClassRayPayloadKHR: return "RayPayloadKHR";
@@ -3358,6 +3596,10 @@ inline const char* SpvDecorationToString(SpvDecoration value) {
     case SpvDecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX";
     case SpvDecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX";
     case SpvDecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX";
+    case SpvDecorationPayloadNodeBaseIndexAMDX: return "PayloadNodeBaseIndexAMDX";
+    case SpvDecorationPayloadNodeSparseArrayAMDX: return "PayloadNodeSparseArrayAMDX";
+    case SpvDecorationPayloadNodeArraySizeAMDX: return "PayloadNodeArraySizeAMDX";
+    case SpvDecorationPayloadDispatchIndirectAMDX: return "PayloadDispatchIndirectAMDX";
     case SpvDecorationOverrideCoverageNV: return "OverrideCoverageNV";
     case SpvDecorationPassthroughNV: return "PassthroughNV";
     case SpvDecorationViewportRelativeNV: return "ViewportRelativeNV";
@@ -3511,7 +3753,7 @@ inline const char* SpvBuiltInToString(SpvBuiltIn value) {
     case SpvBuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD";
     case SpvBuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD";
     case SpvBuiltInFragStencilRefEXT: return "FragStencilRefEXT";
-    case SpvBuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX";
+    case SpvBuiltInRemainingRecursionLevelsAMDX: return "RemainingRecursionLevelsAMDX";
     case SpvBuiltInShaderIndexAMDX: return "ShaderIndexAMDX";
     case SpvBuiltInViewportMaskNV: return "ViewportMaskNV";
     case SpvBuiltInSecondaryPositionNV: return "SecondaryPositionNV";
@@ -3554,12 +3796,19 @@ inline const char* SpvBuiltInToString(SpvBuiltIn value) {
     case SpvBuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
     case SpvBuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR";
     case SpvBuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR";
+    case SpvBuiltInHitIsSphereNV: return "HitIsSphereNV";
+    case SpvBuiltInHitIsLSSNV: return "HitIsLSSNV";
+    case SpvBuiltInHitSpherePositionNV: return "HitSpherePositionNV";
     case SpvBuiltInWarpsPerSMNV: return "WarpsPerSMNV";
     case SpvBuiltInSMCountNV: return "SMCountNV";
     case SpvBuiltInWarpIDNV: return "WarpIDNV";
     case SpvBuiltInSMIDNV: return "SMIDNV";
+    case SpvBuiltInHitLSSPositionsNV: return "HitLSSPositionsNV";
     case SpvBuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
     case SpvBuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
+    case SpvBuiltInHitSphereRadiusNV: return "HitSphereRadiusNV";
+    case SpvBuiltInHitLSSRadiiNV: return "HitLSSRadiiNV";
+    case SpvBuiltInClusterIDNV: return "ClusterIDNV";
     case SpvBuiltInCullMaskKHR: return "CullMaskKHR";
     default: return "Unknown";
     }
@@ -3765,9 +4014,20 @@ inline const char* SpvCapabilityToString(SpvCapability value) {
     case SpvCapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
     case SpvCapabilityBindlessTextureNV: return "BindlessTextureNV";
     case SpvCapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
+    case SpvCapabilityCooperativeVectorNV: return "CooperativeVectorNV";
     case SpvCapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
     case SpvCapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
     case SpvCapabilityRawAccessChainsNV: return "RawAccessChainsNV";
+    case SpvCapabilityRayTracingSpheresGeometryNV: return "RayTracingSpheresGeometryNV";
+    case SpvCapabilityRayTracingLinearSweptSpheresGeometryNV: return "RayTracingLinearSweptSpheresGeometryNV";
+    case SpvCapabilityCooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV";
+    case SpvCapabilityCooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV";
+    case SpvCapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
+    case SpvCapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV";
+    case SpvCapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV";
+    case SpvCapabilityCooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV";
+    case SpvCapabilityRayTracingClusterAccelerationStructureNV: return "RayTracingClusterAccelerationStructureNV";
+    case SpvCapabilityTensorAddressingNV: return "TensorAddressingNV";
     case SpvCapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL";
     case SpvCapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL";
     case SpvCapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL";
@@ -3823,11 +4083,12 @@ inline const char* SpvCapabilityToString(SpvCapability value) {
     case SpvCapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT";
     case SpvCapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT";
     case SpvCapabilityLongCompositesINTEL: return "LongCompositesINTEL";
-    case SpvCapabilityOptNoneINTEL: return "OptNoneINTEL";
+    case SpvCapabilityOptNoneEXT: return "OptNoneEXT";
     case SpvCapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT";
     case SpvCapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL";
     case SpvCapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL";
     case SpvCapabilitySplitBarrierINTEL: return "SplitBarrierINTEL";
+    case SpvCapabilityArithmeticFenceEXT: return "ArithmeticFenceEXT";
     case SpvCapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL";
     case SpvCapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL";
     case SpvCapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL";
@@ -3836,6 +4097,10 @@ inline const char* SpvCapabilityToString(SpvCapability value) {
     case SpvCapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL";
     case SpvCapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL";
     case SpvCapabilitySubgroupBufferPrefetchINTEL: return "SubgroupBufferPrefetchINTEL";
+    case SpvCapabilitySubgroup2DBlockIOINTEL: return "Subgroup2DBlockIOINTEL";
+    case SpvCapabilitySubgroup2DBlockTransformINTEL: return "Subgroup2DBlockTransformINTEL";
+    case SpvCapabilitySubgroup2DBlockTransposeINTEL: return "Subgroup2DBlockTransposeINTEL";
+    case SpvCapabilitySubgroupMatrixMultiplyAccumulateINTEL: return "SubgroupMatrixMultiplyAccumulateINTEL";
     case SpvCapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR";
     case SpvCapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL";
     case SpvCapabilityCacheControlsINTEL: return "CacheControlsINTEL";
@@ -3935,6 +4200,17 @@ inline const char* SpvCooperativeMatrixUseToString(SpvCooperativeMatrixUse value
     }
 }
 
+inline const char* SpvTensorClampModeToString(SpvTensorClampMode value) {
+    switch (value) {
+    case SpvTensorClampModeUndefined: return "Undefined";
+    case SpvTensorClampModeConstant: return "Constant";
+    case SpvTensorClampModeClampToEdge: return "ClampToEdge";
+    case SpvTensorClampModeRepeat: return "Repeat";
+    case SpvTensorClampModeRepeatMirrored: return "RepeatMirrored";
+    default: return "Unknown";
+    }
+}
+
 inline const char* SpvInitializationModeQualifierToString(SpvInitializationModeQualifier value) {
     switch (value) {
     case SpvInitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL";
@@ -3987,6 +4263,37 @@ inline const char* SpvFPEncodingToString(SpvFPEncoding value) {
     }
 }
 
+inline const char* SpvCooperativeVectorMatrixLayoutToString(SpvCooperativeVectorMatrixLayout value) {
+    switch (value) {
+    case SpvCooperativeVectorMatrixLayoutRowMajorNV: return "RowMajorNV";
+    case SpvCooperativeVectorMatrixLayoutColumnMajorNV: return "ColumnMajorNV";
+    case SpvCooperativeVectorMatrixLayoutInferencingOptimalNV: return "InferencingOptimalNV";
+    case SpvCooperativeVectorMatrixLayoutTrainingOptimalNV: return "TrainingOptimalNV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* SpvComponentTypeToString(SpvComponentType value) {
+    switch (value) {
+    case SpvComponentTypeFloat16NV: return "Float16NV";
+    case SpvComponentTypeFloat32NV: return "Float32NV";
+    case SpvComponentTypeFloat64NV: return "Float64NV";
+    case SpvComponentTypeSignedInt8NV: return "SignedInt8NV";
+    case SpvComponentTypeSignedInt16NV: return "SignedInt16NV";
+    case SpvComponentTypeSignedInt32NV: return "SignedInt32NV";
+    case SpvComponentTypeSignedInt64NV: return "SignedInt64NV";
+    case SpvComponentTypeUnsignedInt8NV: return "UnsignedInt8NV";
+    case SpvComponentTypeUnsignedInt16NV: return "UnsignedInt16NV";
+    case SpvComponentTypeUnsignedInt32NV: return "UnsignedInt32NV";
+    case SpvComponentTypeUnsignedInt64NV: return "UnsignedInt64NV";
+    case SpvComponentTypeSignedInt8PackedNV: return "SignedInt8PackedNV";
+    case SpvComponentTypeUnsignedInt8PackedNV: return "UnsignedInt8PackedNV";
+    case SpvComponentTypeFloatE4M3NV: return "FloatE4M3NV";
+    case SpvComponentTypeFloatE5M2NV: return "FloatE5M2NV";
+    default: return "Unknown";
+    }
+}
+
 inline const char* SpvOpToString(SpvOp value) {
     switch (value) {
     case SpvOpNop: return "OpNop";
@@ -4398,9 +4705,14 @@ inline const char* SpvOpToString(SpvOp value) {
     case SpvOpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD";
     case SpvOpFragmentFetchAMD: return "OpFragmentFetchAMD";
     case SpvOpReadClockKHR: return "OpReadClockKHR";
-    case SpvOpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX";
+    case SpvOpAllocateNodePayloadsAMDX: return "OpAllocateNodePayloadsAMDX";
+    case SpvOpEnqueueNodePayloadsAMDX: return "OpEnqueueNodePayloadsAMDX";
+    case SpvOpTypeNodePayloadArrayAMDX: return "OpTypeNodePayloadArrayAMDX";
     case SpvOpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX";
-    case SpvOpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX";
+    case SpvOpNodePayloadArrayLengthAMDX: return "OpNodePayloadArrayLengthAMDX";
+    case SpvOpIsNodePayloadValidAMDX: return "OpIsNodePayloadValidAMDX";
+    case SpvOpConstantStringAMDX: return "OpConstantStringAMDX";
+    case SpvOpSpecConstantStringAMDX: return "OpSpecConstantStringAMDX";
     case SpvOpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
     case SpvOpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
     case SpvOpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV";
@@ -4437,12 +4749,20 @@ inline const char* SpvOpToString(SpvOp value) {
     case SpvOpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
     case SpvOpTypeHitObjectNV: return "OpTypeHitObjectNV";
     case SpvOpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
+    case SpvOpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV";
+    case SpvOpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV";
+    case SpvOpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV";
+    case SpvOpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV";
+    case SpvOpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
+    case SpvOpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV";
     case SpvOpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
     case SpvOpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
     case SpvOpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV";
     case SpvOpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
     case SpvOpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
     case SpvOpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
+    case SpvOpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV";
+    case SpvOpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV";
     case SpvOpReportIntersectionKHR: return "OpReportIntersectionKHR";
     case SpvOpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV";
     case SpvOpTerminateRayNV: return "OpTerminateRayNV";
@@ -4452,6 +4772,8 @@ inline const char* SpvOpToString(SpvOp value) {
     case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
     case SpvOpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR";
     case SpvOpExecuteCallableNV: return "OpExecuteCallableNV";
+    case SpvOpRayQueryGetClusterIdNV: return "OpRayQueryGetClusterIdNV";
+    case SpvOpHitObjectGetClusterIdNV: return "OpHitObjectGetClusterIdNV";
     case SpvOpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV";
     case SpvOpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV";
     case SpvOpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV";
@@ -4459,8 +4781,25 @@ inline const char* SpvOpToString(SpvOp value) {
     case SpvOpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV";
     case SpvOpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
     case SpvOpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
+    case SpvOpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV";
+    case SpvOpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV";
+    case SpvOpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV";
+    case SpvOpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
+    case SpvOpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV";
+    case SpvOpTypeTensorViewNV: return "OpTypeTensorViewNV";
+    case SpvOpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV";
+    case SpvOpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV";
+    case SpvOpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV";
+    case SpvOpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV";
+    case SpvOpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV";
+    case SpvOpCreateTensorViewNV: return "OpCreateTensorViewNV";
+    case SpvOpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV";
+    case SpvOpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV";
     case SpvOpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation";
     case SpvOpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT";
+    case SpvOpTensorViewSetClipNV: return "OpTensorViewSetClipNV";
+    case SpvOpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV";
+    case SpvOpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV";
     case SpvOpConvertUToImageNV: return "OpConvertUToImageNV";
     case SpvOpConvertUToSamplerNV: return "OpConvertUToSamplerNV";
     case SpvOpConvertImageToUNV: return "OpConvertImageToUNV";
@@ -4469,6 +4808,19 @@ inline const char* SpvOpToString(SpvOp value) {
     case SpvOpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV";
     case SpvOpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV";
     case SpvOpRawAccessChainNV: return "OpRawAccessChainNV";
+    case SpvOpRayQueryGetIntersectionSpherePositionNV: return "OpRayQueryGetIntersectionSpherePositionNV";
+    case SpvOpRayQueryGetIntersectionSphereRadiusNV: return "OpRayQueryGetIntersectionSphereRadiusNV";
+    case SpvOpRayQueryGetIntersectionLSSPositionsNV: return "OpRayQueryGetIntersectionLSSPositionsNV";
+    case SpvOpRayQueryGetIntersectionLSSRadiiNV: return "OpRayQueryGetIntersectionLSSRadiiNV";
+    case SpvOpRayQueryGetIntersectionLSSHitValueNV: return "OpRayQueryGetIntersectionLSSHitValueNV";
+    case SpvOpHitObjectGetSpherePositionNV: return "OpHitObjectGetSpherePositionNV";
+    case SpvOpHitObjectGetSphereRadiusNV: return "OpHitObjectGetSphereRadiusNV";
+    case SpvOpHitObjectGetLSSPositionsNV: return "OpHitObjectGetLSSPositionsNV";
+    case SpvOpHitObjectGetLSSRadiiNV: return "OpHitObjectGetLSSRadiiNV";
+    case SpvOpHitObjectIsSphereHitNV: return "OpHitObjectIsSphereHitNV";
+    case SpvOpHitObjectIsLSSHitNV: return "OpHitObjectIsLSSHitNV";
+    case SpvOpRayQueryIsSphereHitNV: return "OpRayQueryIsSphereHitNV";
+    case SpvOpRayQueryIsLSSHitNV: return "OpRayQueryIsLSSHitNV";
     case SpvOpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL";
     case SpvOpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL";
     case SpvOpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL";
@@ -4713,7 +5065,14 @@ inline const char* SpvOpToString(SpvOp value) {
     case SpvOpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL";
     case SpvOpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL";
     case SpvOpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL";
+    case SpvOpArithmeticFenceEXT: return "OpArithmeticFenceEXT";
     case SpvOpSubgroupBlockPrefetchINTEL: return "OpSubgroupBlockPrefetchINTEL";
+    case SpvOpSubgroup2DBlockLoadINTEL: return "OpSubgroup2DBlockLoadINTEL";
+    case SpvOpSubgroup2DBlockLoadTransformINTEL: return "OpSubgroup2DBlockLoadTransformINTEL";
+    case SpvOpSubgroup2DBlockLoadTransposeINTEL: return "OpSubgroup2DBlockLoadTransposeINTEL";
+    case SpvOpSubgroup2DBlockPrefetchINTEL: return "OpSubgroup2DBlockPrefetchINTEL";
+    case SpvOpSubgroup2DBlockStoreINTEL: return "OpSubgroup2DBlockStoreINTEL";
+    case SpvOpSubgroupMatrixMultiplyAccumulateINTEL: return "OpSubgroupMatrixMultiplyAccumulateINTEL";
     case SpvOpGroupIMulKHR: return "OpGroupIMulKHR";
     case SpvOpGroupFMulKHR: return "OpGroupFMulKHR";
     case SpvOpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR";

include/vulkan/spirv-headers/spirv.hpp

@@ -74,6 +74,7 @@ enum SourceLanguage {
     SourceLanguageWGSL = 10,
     SourceLanguageSlang = 11,
     SourceLanguageZig = 12,
+    SourceLanguageRust = 13,
     SourceLanguageMax = 0x7fffffff,
 };
 
@@ -174,6 +175,7 @@ enum ExecutionMode {
     ExecutionModeEarlyAndLateFragmentTestsAMD = 5017,
     ExecutionModeStencilRefReplacingEXT = 5027,
     ExecutionModeCoalescingAMDX = 5069,
+    ExecutionModeIsApiEntryAMDX = 5070,
     ExecutionModeMaxNodeRecursionAMDX = 5071,
     ExecutionModeStaticNumWorkgroupsAMDX = 5072,
     ExecutionModeShaderIndexAMDX = 5073,
@@ -186,6 +188,7 @@ enum ExecutionMode {
     ExecutionModeStencilRefLessBackAMD = 5084,
     ExecutionModeQuadDerivativesKHR = 5088,
     ExecutionModeRequireFullQuadsKHR = 5089,
+    ExecutionModeSharesInputWithAMDX = 5102,
     ExecutionModeOutputLinesEXT = 5269,
     ExecutionModeOutputLinesNV = 5269,
     ExecutionModeOutputPrimitivesEXT = 5270,
@@ -239,7 +242,6 @@ enum StorageClass {
     StorageClassStorageBuffer = 12,
     StorageClassTileImageEXT = 4172,
     StorageClassNodePayloadAMDX = 5068,
-    StorageClassNodeOutputPayloadAMDX = 5076,
     StorageClassCallableDataKHR = 5328,
     StorageClassCallableDataNV = 5328,
     StorageClassIncomingCallableDataKHR = 5329,
@@ -552,6 +554,10 @@ enum Decoration {
     DecorationNodeMaxPayloadsAMDX = 5020,
     DecorationTrackFinishWritingAMDX = 5078,
     DecorationPayloadNodeNameAMDX = 5091,
+    DecorationPayloadNodeBaseIndexAMDX = 5098,
+    DecorationPayloadNodeSparseArrayAMDX = 5099,
+    DecorationPayloadNodeArraySizeAMDX = 5100,
+    DecorationPayloadDispatchIndirectAMDX = 5105,
     DecorationOverrideCoverageNV = 5248,
     DecorationPassthroughNV = 5250,
     DecorationViewportRelativeNV = 5252,
@@ -715,7 +721,7 @@ enum BuiltIn {
     BuiltInBaryCoordSmoothSampleAMD = 4997,
     BuiltInBaryCoordPullModelAMD = 4998,
     BuiltInFragStencilRefEXT = 5014,
-    BuiltInCoalescedInputCountAMDX = 5021,
+    BuiltInRemainingRecursionLevelsAMDX = 5021,
     BuiltInShaderIndexAMDX = 5073,
     BuiltInViewportMaskNV = 5253,
     BuiltInSecondaryPositionNV = 5257,
@@ -775,12 +781,19 @@ enum BuiltIn {
     BuiltInIncomingRayFlagsKHR = 5351,
     BuiltInIncomingRayFlagsNV = 5351,
     BuiltInRayGeometryIndexKHR = 5352,
+    BuiltInHitIsSphereNV = 5359,
+    BuiltInHitIsLSSNV = 5360,
+    BuiltInHitSpherePositionNV = 5361,
     BuiltInWarpsPerSMNV = 5374,
     BuiltInSMCountNV = 5375,
     BuiltInWarpIDNV = 5376,
     BuiltInSMIDNV = 5377,
+    BuiltInHitLSSPositionsNV = 5396,
     BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
     BuiltInHitKindBackFacingMicroTriangleNV = 5406,
+    BuiltInHitSphereRadiusNV = 5420,
+    BuiltInHitLSSRadiiNV = 5421,
+    BuiltInClusterIDNV = 5436,
     BuiltInCullMaskKHR = 6021,
     BuiltInMax = 0x7fffffff,
 };
@@ -848,6 +861,7 @@ enum FunctionControlShift {
     FunctionControlDontInlineShift = 1,
     FunctionControlPureShift = 2,
     FunctionControlConstShift = 3,
+    FunctionControlOptNoneEXTShift = 16,
     FunctionControlOptNoneINTELShift = 16,
     FunctionControlMax = 0x7fffffff,
 };
@@ -858,6 +872,7 @@ enum FunctionControlMask {
     FunctionControlDontInlineMask = 0x00000002,
     FunctionControlPureMask = 0x00000004,
     FunctionControlConstMask = 0x00000008,
+    FunctionControlOptNoneEXTMask = 0x00010000,
     FunctionControlOptNoneINTELMask = 0x00010000,
 };
 
@@ -1160,9 +1175,20 @@ enum Capability {
     CapabilityShaderInvocationReorderNV = 5383,
     CapabilityBindlessTextureNV = 5390,
     CapabilityRayQueryPositionFetchKHR = 5391,
+    CapabilityCooperativeVectorNV = 5394,
     CapabilityAtomicFloat16VectorNV = 5404,
     CapabilityRayTracingDisplacementMicromapNV = 5409,
     CapabilityRawAccessChainsNV = 5414,
+    CapabilityRayTracingSpheresGeometryNV = 5418,
+    CapabilityRayTracingLinearSweptSpheresGeometryNV = 5419,
+    CapabilityCooperativeMatrixReductionsNV = 5430,
+    CapabilityCooperativeMatrixConversionsNV = 5431,
+    CapabilityCooperativeMatrixPerElementOperationsNV = 5432,
+    CapabilityCooperativeMatrixTensorAddressingNV = 5433,
+    CapabilityCooperativeMatrixBlockLoadsNV = 5434,
+    CapabilityCooperativeVectorTrainingNV = 5435,
+    CapabilityRayTracingClusterAccelerationStructureNV = 5437,
+    CapabilityTensorAddressingNV = 5439,
     CapabilitySubgroupShuffleINTEL = 5568,
     CapabilitySubgroupBufferBlockIOINTEL = 5569,
     CapabilitySubgroupImageBlockIOINTEL = 5570,
@@ -1222,11 +1248,13 @@ enum Capability {
     CapabilityAtomicFloat32AddEXT = 6033,
     CapabilityAtomicFloat64AddEXT = 6034,
     CapabilityLongCompositesINTEL = 6089,
+    CapabilityOptNoneEXT = 6094,
     CapabilityOptNoneINTEL = 6094,
     CapabilityAtomicFloat16AddEXT = 6095,
     CapabilityDebugInfoModuleINTEL = 6114,
     CapabilityBFloat16ConversionINTEL = 6115,
     CapabilitySplitBarrierINTEL = 6141,
+    CapabilityArithmeticFenceEXT = 6144,
     CapabilityFPGAClusterAttributesV2INTEL = 6150,
     CapabilityFPGAKernelAttributesv2INTEL = 6161,
     CapabilityFPMaxErrorINTEL = 6169,
@@ -1235,6 +1263,10 @@ enum Capability {
     CapabilityGlobalVariableHostAccessINTEL = 6187,
     CapabilityGlobalVariableFPGADecorationsINTEL = 6189,
     CapabilitySubgroupBufferPrefetchINTEL = 6220,
+    CapabilitySubgroup2DBlockIOINTEL = 6228,
+    CapabilitySubgroup2DBlockTransformINTEL = 6229,
+    CapabilitySubgroup2DBlockTransposeINTEL = 6230,
+    CapabilitySubgroupMatrixMultiplyAccumulateINTEL = 6236,
     CapabilityGroupUniformArithmeticKHR = 6400,
     CapabilityMaskedGatherScatterINTEL = 6427,
     CapabilityCacheControlsINTEL = 6441,
@@ -1251,6 +1283,7 @@ enum RayFlagsShift {
     RayFlagsCullFrontFacingTrianglesKHRShift = 5,
     RayFlagsCullOpaqueKHRShift = 6,
     RayFlagsCullNoOpaqueKHRShift = 7,
+    RayFlagsSkipBuiltinPrimitivesNVShift = 8,
     RayFlagsSkipTrianglesKHRShift = 8,
     RayFlagsSkipAABBsKHRShift = 9,
     RayFlagsForceOpacityMicromap2StateEXTShift = 10,
@@ -1267,6 +1300,7 @@ enum RayFlagsMask {
     RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
     RayFlagsCullOpaqueKHRMask = 0x00000040,
     RayFlagsCullNoOpaqueKHRMask = 0x00000080,
+    RayFlagsSkipBuiltinPrimitivesNVMask = 0x00000100,
     RayFlagsSkipTrianglesKHRMask = 0x00000100,
     RayFlagsSkipAABBsKHRMask = 0x00000200,
     RayFlagsForceOpacityMicromap2StateEXTMask = 0x00000400,
@@ -1378,6 +1412,41 @@ enum CooperativeMatrixUse {
     CooperativeMatrixUseMax = 0x7fffffff,
 };
 
+enum CooperativeMatrixReduceShift {
+    CooperativeMatrixReduceRowShift = 0,
+    CooperativeMatrixReduceColumnShift = 1,
+    CooperativeMatrixReduce2x2Shift = 2,
+    CooperativeMatrixReduceMax = 0x7fffffff,
+};
+
+enum CooperativeMatrixReduceMask {
+    CooperativeMatrixReduceMaskNone = 0,
+    CooperativeMatrixReduceRowMask = 0x00000001,
+    CooperativeMatrixReduceColumnMask = 0x00000002,
+    CooperativeMatrixReduce2x2Mask = 0x00000004,
+};
+
+enum TensorClampMode {
+    TensorClampModeUndefined = 0,
+    TensorClampModeConstant = 1,
+    TensorClampModeClampToEdge = 2,
+    TensorClampModeRepeat = 3,
+    TensorClampModeRepeatMirrored = 4,
+    TensorClampModeMax = 0x7fffffff,
+};
+
+enum TensorAddressingOperandsShift {
+    TensorAddressingOperandsTensorViewShift = 0,
+    TensorAddressingOperandsDecodeFuncShift = 1,
+    TensorAddressingOperandsMax = 0x7fffffff,
+};
+
+enum TensorAddressingOperandsMask {
+    TensorAddressingOperandsMaskNone = 0,
+    TensorAddressingOperandsTensorViewMask = 0x00000001,
+    TensorAddressingOperandsDecodeFuncMask = 0x00000002,
+};
+
 enum InitializationModeQualifier {
     InitializationModeQualifierInitOnDeviceReprogramINTEL = 0,
     InitializationModeQualifierInitOnDeviceResetINTEL = 1,
@@ -1414,6 +1483,42 @@ enum NamedMaximumNumberOfRegisters {
     NamedMaximumNumberOfRegistersMax = 0x7fffffff,
 };
 
+enum MatrixMultiplyAccumulateOperandsShift {
+    MatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELShift = 0,
+    MatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELShift = 1,
+    MatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELShift = 2,
+    MatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELShift = 3,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELShift = 4,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELShift = 5,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELShift = 6,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELShift = 7,
+    MatrixMultiplyAccumulateOperandsMatrixATF32INTELShift = 8,
+    MatrixMultiplyAccumulateOperandsMatrixBTF32INTELShift = 9,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELShift = 10,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELShift = 11,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELShift = 12,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELShift = 13,
+    MatrixMultiplyAccumulateOperandsMax = 0x7fffffff,
+};
+
+enum MatrixMultiplyAccumulateOperandsMask {
+    MatrixMultiplyAccumulateOperandsMaskNone = 0,
+    MatrixMultiplyAccumulateOperandsMatrixASignedComponentsINTELMask = 0x00000001,
+    MatrixMultiplyAccumulateOperandsMatrixBSignedComponentsINTELMask = 0x00000002,
+    MatrixMultiplyAccumulateOperandsMatrixCBFloat16INTELMask = 0x00000004,
+    MatrixMultiplyAccumulateOperandsMatrixResultBFloat16INTELMask = 0x00000008,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedInt8INTELMask = 0x00000010,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedInt8INTELMask = 0x00000020,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedInt4INTELMask = 0x00000040,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedInt4INTELMask = 0x00000080,
+    MatrixMultiplyAccumulateOperandsMatrixATF32INTELMask = 0x00000100,
+    MatrixMultiplyAccumulateOperandsMatrixBTF32INTELMask = 0x00000200,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedFloat16INTELMask = 0x00000400,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedFloat16INTELMask = 0x00000800,
+    MatrixMultiplyAccumulateOperandsMatrixAPackedBFloat16INTELMask = 0x00001000,
+    MatrixMultiplyAccumulateOperandsMatrixBPackedBFloat16INTELMask = 0x00002000,
+};
+
 enum RawAccessChainOperandsShift {
     RawAccessChainOperandsRobustnessPerComponentNVShift = 0,
     RawAccessChainOperandsRobustnessPerElementNVShift = 1,
@@ -1430,6 +1535,33 @@ enum FPEncoding {
     FPEncodingMax = 0x7fffffff,
 };
 
+enum CooperativeVectorMatrixLayout {
+    CooperativeVectorMatrixLayoutRowMajorNV = 0,
+    CooperativeVectorMatrixLayoutColumnMajorNV = 1,
+    CooperativeVectorMatrixLayoutInferencingOptimalNV = 2,
+    CooperativeVectorMatrixLayoutTrainingOptimalNV = 3,
+    CooperativeVectorMatrixLayoutMax = 0x7fffffff,
+};
+
+enum ComponentType {
+    ComponentTypeFloat16NV = 0,
+    ComponentTypeFloat32NV = 1,
+    ComponentTypeFloat64NV = 2,
+    ComponentTypeSignedInt8NV = 3,
+    ComponentTypeSignedInt16NV = 4,
+    ComponentTypeSignedInt32NV = 5,
+    ComponentTypeSignedInt64NV = 6,
+    ComponentTypeUnsignedInt8NV = 7,
+    ComponentTypeUnsignedInt16NV = 8,
+    ComponentTypeUnsignedInt32NV = 9,
+    ComponentTypeUnsignedInt64NV = 10,
+    ComponentTypeSignedInt8PackedNV = 1000491000,
+    ComponentTypeUnsignedInt8PackedNV = 1000491001,
+    ComponentTypeFloatE4M3NV = 1000491002,
+    ComponentTypeFloatE5M2NV = 1000491003,
+    ComponentTypeMax = 0x7fffffff,
+};
+
 enum Op {
     OpNop = 0,
     OpUndef = 1,
@@ -1846,9 +1978,14 @@ enum Op {
     OpFragmentMaskFetchAMD = 5011,
     OpFragmentFetchAMD = 5012,
     OpReadClockKHR = 5056,
-    OpFinalizeNodePayloadsAMDX = 5075,
+    OpAllocateNodePayloadsAMDX = 5074,
+    OpEnqueueNodePayloadsAMDX = 5075,
+    OpTypeNodePayloadArrayAMDX = 5076,
     OpFinishWritingNodePayloadAMDX = 5078,
-    OpInitializeNodePayloadsAMDX = 5090,
+    OpNodePayloadArrayLengthAMDX = 5090,
+    OpIsNodePayloadValidAMDX = 5101,
+    OpConstantStringAMDX = 5103,
+    OpSpecConstantStringAMDX = 5104,
     OpGroupNonUniformQuadAllKHR = 5110,
     OpGroupNonUniformQuadAnyKHR = 5111,
     OpHitObjectRecordHitMotionNV = 5249,
@@ -1885,12 +2022,20 @@ enum Op {
     OpReorderThreadWithHintNV = 5280,
     OpTypeHitObjectNV = 5281,
     OpImageSampleFootprintNV = 5283,
+    OpTypeCooperativeVectorNV = 5288,
+    OpCooperativeVectorMatrixMulNV = 5289,
+    OpCooperativeVectorOuterProductAccumulateNV = 5290,
+    OpCooperativeVectorReduceSumAccumulateNV = 5291,
+    OpCooperativeVectorMatrixMulAddNV = 5292,
+    OpCooperativeMatrixConvertNV = 5293,
     OpEmitMeshTasksEXT = 5294,
     OpSetMeshOutputsEXT = 5295,
     OpGroupNonUniformPartitionNV = 5296,
     OpWritePackedPrimitiveIndices4x8NV = 5299,
     OpFetchMicroTriangleVertexPositionNV = 5300,
     OpFetchMicroTriangleVertexBarycentricNV = 5301,
+    OpCooperativeVectorLoadNV = 5302,
+    OpCooperativeVectorStoreNV = 5303,
     OpReportIntersectionKHR = 5334,
     OpReportIntersectionNV = 5334,
     OpIgnoreIntersectionNV = 5335,
@@ -1902,6 +2047,8 @@ enum Op {
     OpTypeAccelerationStructureKHR = 5341,
     OpTypeAccelerationStructureNV = 5341,
     OpExecuteCallableNV = 5344,
+    OpRayQueryGetClusterIdNV = 5345,
+    OpHitObjectGetClusterIdNV = 5346,
     OpTypeCooperativeMatrixNV = 5358,
     OpCooperativeMatrixLoadNV = 5359,
     OpCooperativeMatrixStoreNV = 5360,
@@ -1909,9 +2056,26 @@ enum Op {
     OpCooperativeMatrixLengthNV = 5362,
     OpBeginInvocationInterlockEXT = 5364,
     OpEndInvocationInterlockEXT = 5365,
+    OpCooperativeMatrixReduceNV = 5366,
+    OpCooperativeMatrixLoadTensorNV = 5367,
+    OpCooperativeMatrixStoreTensorNV = 5368,
+    OpCooperativeMatrixPerElementOpNV = 5369,
+    OpTypeTensorLayoutNV = 5370,
+    OpTypeTensorViewNV = 5371,
+    OpCreateTensorLayoutNV = 5372,
+    OpTensorLayoutSetDimensionNV = 5373,
+    OpTensorLayoutSetStrideNV = 5374,
+    OpTensorLayoutSliceNV = 5375,
+    OpTensorLayoutSetClampValueNV = 5376,
+    OpCreateTensorViewNV = 5377,
+    OpTensorViewSetDimensionNV = 5378,
+    OpTensorViewSetStrideNV = 5379,
     OpDemoteToHelperInvocation = 5380,
     OpDemoteToHelperInvocationEXT = 5380,
     OpIsHelperInvocationEXT = 5381,
+    OpTensorViewSetClipNV = 5382,
+    OpTensorLayoutSetBlockSizeNV = 5384,
+    OpCooperativeMatrixTransposeNV = 5390,
     OpConvertUToImageNV = 5391,
     OpConvertUToSamplerNV = 5392,
     OpConvertImageToUNV = 5393,
@@ -1920,6 +2084,19 @@ enum Op {
     OpConvertSampledImageToUNV = 5396,
     OpSamplerImageAddressingModeNV = 5397,
     OpRawAccessChainNV = 5398,
+    OpRayQueryGetIntersectionSpherePositionNV = 5427,
+    OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+    OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+    OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+    OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+    OpHitObjectGetSpherePositionNV = 5432,
+    OpHitObjectGetSphereRadiusNV = 5433,
+    OpHitObjectGetLSSPositionsNV = 5434,
+    OpHitObjectGetLSSRadiiNV = 5435,
+    OpHitObjectIsSphereHitNV = 5436,
+    OpHitObjectIsLSSHitNV = 5437,
+    OpRayQueryIsSphereHitNV = 5438,
+    OpRayQueryIsLSSHitNV = 5439,
     OpSubgroupShuffleINTEL = 5571,
     OpSubgroupShuffleDownINTEL = 5572,
     OpSubgroupShuffleUpINTEL = 5573,
@@ -2166,7 +2343,14 @@ enum Op {
     OpConvertBF16ToFINTEL = 6117,
     OpControlBarrierArriveINTEL = 6142,
     OpControlBarrierWaitINTEL = 6143,
+    OpArithmeticFenceEXT = 6145,
     OpSubgroupBlockPrefetchINTEL = 6221,
+    OpSubgroup2DBlockLoadINTEL = 6231,
+    OpSubgroup2DBlockLoadTransformINTEL = 6232,
+    OpSubgroup2DBlockLoadTransposeINTEL = 6233,
+    OpSubgroup2DBlockPrefetchINTEL = 6234,
+    OpSubgroup2DBlockStoreINTEL = 6235,
+    OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
     OpGroupIMulKHR = 6401,
     OpGroupFMulKHR = 6402,
     OpGroupBitwiseAndKHR = 6403,
@@ -2597,9 +2781,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
     case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
     case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
-    case OpFinalizeNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case OpAllocateNodePayloadsAMDX: *hasResult = true; *hasResultType = true; break;
+    case OpEnqueueNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case OpTypeNodePayloadArrayAMDX: *hasResult = true; *hasResultType = false; break;
     case OpFinishWritingNodePayloadAMDX: *hasResult = true; *hasResultType = true; break;
-    case OpInitializeNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case OpNodePayloadArrayLengthAMDX: *hasResult = true; *hasResultType = true; break;
+    case OpIsNodePayloadValidAMDX: *hasResult = true; *hasResultType = true; break;
+    case OpConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
+    case OpSpecConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
     case OpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break;
     case OpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break;
     case OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
@@ -2636,12 +2825,20 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
     case OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
     case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
+    case OpTypeCooperativeVectorNV: *hasResult = true; *hasResultType = false; break;
+    case OpCooperativeVectorMatrixMulNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeVectorOuterProductAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case OpCooperativeVectorReduceSumAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case OpCooperativeVectorMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeMatrixConvertNV: *hasResult = true; *hasResultType = true; break;
     case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
     case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
     case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
     case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
     case OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break;
     case OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeVectorLoadNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeVectorStoreNV: *hasResult = false; *hasResultType = false; break;
     case OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break;
     case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
     case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
@@ -2651,6 +2848,8 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
     case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break;
     case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+    case OpRayQueryGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
     case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
     case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
     case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
@@ -2658,8 +2857,25 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
     case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
     case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case OpCooperativeMatrixReduceNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeMatrixLoadTensorNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeMatrixStoreTensorNV: *hasResult = false; *hasResultType = false; break;
+    case OpCooperativeMatrixPerElementOpNV: *hasResult = true; *hasResultType = true; break;
+    case OpTypeTensorLayoutNV: *hasResult = true; *hasResultType = false; break;
+    case OpTypeTensorViewNV: *hasResult = true; *hasResultType = false; break;
+    case OpCreateTensorLayoutNV: *hasResult = true; *hasResultType = true; break;
+    case OpTensorLayoutSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case OpTensorLayoutSetStrideNV: *hasResult = true; *hasResultType = true; break;
+    case OpTensorLayoutSliceNV: *hasResult = true; *hasResultType = true; break;
+    case OpTensorLayoutSetClampValueNV: *hasResult = true; *hasResultType = true; break;
+    case OpCreateTensorViewNV: *hasResult = true; *hasResultType = true; break;
+    case OpTensorViewSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case OpTensorViewSetStrideNV: *hasResult = true; *hasResultType = true; break;
     case OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
     case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
+    case OpTensorViewSetClipNV: *hasResult = true; *hasResultType = true; break;
+    case OpTensorLayoutSetBlockSizeNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeMatrixTransposeNV: *hasResult = true; *hasResultType = true; break;
     case OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;
     case OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;
     case OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;
@@ -2668,6 +2884,19 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
     case OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;
     case OpRawAccessChainNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionLSSHitValueNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectGetSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectGetSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectGetLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectGetLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectIsLSSHitNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryIsLSSHitNV: *hasResult = true; *hasResultType = true; break;
     case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
     case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
     case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
@@ -2694,7 +2923,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
     case OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
     case OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAsmTargetINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpAsmTargetINTEL: *hasResult = true; *hasResultType = false; break;
     case OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
     case OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
     case OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
@@ -2912,7 +3141,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpConvertBF16ToFINTEL: *hasResult = true; *hasResultType = true; break;
     case OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
     case OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpArithmeticFenceEXT: *hasResult = true; *hasResultType = true; break;
     case OpSubgroupBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroup2DBlockLoadINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroup2DBlockLoadTransformINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroup2DBlockLoadTransposeINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroup2DBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroup2DBlockStoreINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSubgroupMatrixMultiplyAccumulateINTEL: *hasResult = true; *hasResultType = true; break;
     case OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
     case OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
     case OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
@@ -2940,6 +3176,7 @@ inline const char* SourceLanguageToString(SourceLanguage value) {
     case SourceLanguageWGSL: return "WGSL";
     case SourceLanguageSlang: return "Slang";
     case SourceLanguageZig: return "Zig";
+    case SourceLanguageRust: return "Rust";
     default: return "Unknown";
     }
 }
@@ -3040,6 +3277,7 @@ inline const char* ExecutionModeToString(ExecutionMode value) {
     case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD";
     case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT";
     case ExecutionModeCoalescingAMDX: return "CoalescingAMDX";
+    case ExecutionModeIsApiEntryAMDX: return "IsApiEntryAMDX";
     case ExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX";
     case ExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX";
     case ExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX";
@@ -3052,6 +3290,7 @@ inline const char* ExecutionModeToString(ExecutionMode value) {
     case ExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD";
     case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR";
     case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR";
+    case ExecutionModeSharesInputWithAMDX: return "SharesInputWithAMDX";
     case ExecutionModeOutputLinesEXT: return "OutputLinesEXT";
     case ExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT";
     case ExecutionModeDerivativeGroupQuadsKHR: return "DerivativeGroupQuadsKHR";
@@ -3102,7 +3341,6 @@ inline const char* StorageClassToString(StorageClass value) {
     case StorageClassStorageBuffer: return "StorageBuffer";
     case StorageClassTileImageEXT: return "TileImageEXT";
     case StorageClassNodePayloadAMDX: return "NodePayloadAMDX";
-    case StorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX";
     case StorageClassCallableDataKHR: return "CallableDataKHR";
     case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR";
     case StorageClassRayPayloadKHR: return "RayPayloadKHR";
@@ -3354,6 +3592,10 @@ inline const char* DecorationToString(Decoration value) {
     case DecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX";
     case DecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX";
     case DecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX";
+    case DecorationPayloadNodeBaseIndexAMDX: return "PayloadNodeBaseIndexAMDX";
+    case DecorationPayloadNodeSparseArrayAMDX: return "PayloadNodeSparseArrayAMDX";
+    case DecorationPayloadNodeArraySizeAMDX: return "PayloadNodeArraySizeAMDX";
+    case DecorationPayloadDispatchIndirectAMDX: return "PayloadDispatchIndirectAMDX";
     case DecorationOverrideCoverageNV: return "OverrideCoverageNV";
     case DecorationPassthroughNV: return "PassthroughNV";
     case DecorationViewportRelativeNV: return "ViewportRelativeNV";
@@ -3507,7 +3749,7 @@ inline const char* BuiltInToString(BuiltIn value) {
     case BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD";
     case BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD";
     case BuiltInFragStencilRefEXT: return "FragStencilRefEXT";
-    case BuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX";
+    case BuiltInRemainingRecursionLevelsAMDX: return "RemainingRecursionLevelsAMDX";
     case BuiltInShaderIndexAMDX: return "ShaderIndexAMDX";
     case BuiltInViewportMaskNV: return "ViewportMaskNV";
     case BuiltInSecondaryPositionNV: return "SecondaryPositionNV";
@@ -3550,12 +3792,19 @@ inline const char* BuiltInToString(BuiltIn value) {
     case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
     case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR";
     case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR";
+    case BuiltInHitIsSphereNV: return "HitIsSphereNV";
+    case BuiltInHitIsLSSNV: return "HitIsLSSNV";
+    case BuiltInHitSpherePositionNV: return "HitSpherePositionNV";
     case BuiltInWarpsPerSMNV: return "WarpsPerSMNV";
     case BuiltInSMCountNV: return "SMCountNV";
     case BuiltInWarpIDNV: return "WarpIDNV";
     case BuiltInSMIDNV: return "SMIDNV";
+    case BuiltInHitLSSPositionsNV: return "HitLSSPositionsNV";
     case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
     case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
+    case BuiltInHitSphereRadiusNV: return "HitSphereRadiusNV";
+    case BuiltInHitLSSRadiiNV: return "HitLSSRadiiNV";
+    case BuiltInClusterIDNV: return "ClusterIDNV";
     case BuiltInCullMaskKHR: return "CullMaskKHR";
     default: return "Unknown";
     }
@@ -3761,9 +4010,20 @@ inline const char* CapabilityToString(Capability value) {
     case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
     case CapabilityBindlessTextureNV: return "BindlessTextureNV";
     case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
+    case CapabilityCooperativeVectorNV: return "CooperativeVectorNV";
     case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
     case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
     case CapabilityRawAccessChainsNV: return "RawAccessChainsNV";
+    case CapabilityRayTracingSpheresGeometryNV: return "RayTracingSpheresGeometryNV";
+    case CapabilityRayTracingLinearSweptSpheresGeometryNV: return "RayTracingLinearSweptSpheresGeometryNV";
+    case CapabilityCooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV";
+    case CapabilityCooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV";
+    case CapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
+    case CapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV";
+    case CapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV";
+    case CapabilityCooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV";
+    case CapabilityRayTracingClusterAccelerationStructureNV: return "RayTracingClusterAccelerationStructureNV";
+    case CapabilityTensorAddressingNV: return "TensorAddressingNV";
     case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL";
     case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL";
     case CapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL";
@@ -3819,11 +4079,12 @@ inline const char* CapabilityToString(Capability value) {
     case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT";
     case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT";
     case CapabilityLongCompositesINTEL: return "LongCompositesINTEL";
-    case CapabilityOptNoneINTEL: return "OptNoneINTEL";
+    case CapabilityOptNoneEXT: return "OptNoneEXT";
     case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT";
     case CapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL";
     case CapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL";
     case CapabilitySplitBarrierINTEL: return "SplitBarrierINTEL";
+    case CapabilityArithmeticFenceEXT: return "ArithmeticFenceEXT";
     case CapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL";
     case CapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL";
     case CapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL";
@@ -3832,6 +4093,10 @@ inline const char* CapabilityToString(Capability value) {
     case CapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL";
     case CapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL";
     case CapabilitySubgroupBufferPrefetchINTEL: return "SubgroupBufferPrefetchINTEL";
+    case CapabilitySubgroup2DBlockIOINTEL: return "Subgroup2DBlockIOINTEL";
+    case CapabilitySubgroup2DBlockTransformINTEL: return "Subgroup2DBlockTransformINTEL";
+    case CapabilitySubgroup2DBlockTransposeINTEL: return "Subgroup2DBlockTransposeINTEL";
+    case CapabilitySubgroupMatrixMultiplyAccumulateINTEL: return "SubgroupMatrixMultiplyAccumulateINTEL";
     case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR";
     case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL";
     case CapabilityCacheControlsINTEL: return "CacheControlsINTEL";
@@ -3931,6 +4196,17 @@ inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) {
     }
 }
 
+inline const char* TensorClampModeToString(TensorClampMode value) {
+    switch (value) {
+    case TensorClampModeUndefined: return "Undefined";
+    case TensorClampModeConstant: return "Constant";
+    case TensorClampModeClampToEdge: return "ClampToEdge";
+    case TensorClampModeRepeat: return "Repeat";
+    case TensorClampModeRepeatMirrored: return "RepeatMirrored";
+    default: return "Unknown";
+    }
+}
+
 inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) {
     switch (value) {
     case InitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL";
@@ -3983,6 +4259,37 @@ inline const char* FPEncodingToString(FPEncoding value) {
     }
 }
 
+inline const char* CooperativeVectorMatrixLayoutToString(CooperativeVectorMatrixLayout value) {
+    switch (value) {
+    case CooperativeVectorMatrixLayoutRowMajorNV: return "RowMajorNV";
+    case CooperativeVectorMatrixLayoutColumnMajorNV: return "ColumnMajorNV";
+    case CooperativeVectorMatrixLayoutInferencingOptimalNV: return "InferencingOptimalNV";
+    case CooperativeVectorMatrixLayoutTrainingOptimalNV: return "TrainingOptimalNV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ComponentTypeToString(ComponentType value) {
+    switch (value) {
+    case ComponentTypeFloat16NV: return "Float16NV";
+    case ComponentTypeFloat32NV: return "Float32NV";
+    case ComponentTypeFloat64NV: return "Float64NV";
+    case ComponentTypeSignedInt8NV: return "SignedInt8NV";
+    case ComponentTypeSignedInt16NV: return "SignedInt16NV";
+    case ComponentTypeSignedInt32NV: return "SignedInt32NV";
+    case ComponentTypeSignedInt64NV: return "SignedInt64NV";
+    case ComponentTypeUnsignedInt8NV: return "UnsignedInt8NV";
+    case ComponentTypeUnsignedInt16NV: return "UnsignedInt16NV";
+    case ComponentTypeUnsignedInt32NV: return "UnsignedInt32NV";
+    case ComponentTypeUnsignedInt64NV: return "UnsignedInt64NV";
+    case ComponentTypeSignedInt8PackedNV: return "SignedInt8PackedNV";
+    case ComponentTypeUnsignedInt8PackedNV: return "UnsignedInt8PackedNV";
+    case ComponentTypeFloatE4M3NV: return "FloatE4M3NV";
+    case ComponentTypeFloatE5M2NV: return "FloatE5M2NV";
+    default: return "Unknown";
+    }
+}
+
 inline const char* OpToString(Op value) {
     switch (value) {
     case OpNop: return "OpNop";
@@ -4394,9 +4701,14 @@ inline const char* OpToString(Op value) {
     case OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD";
     case OpFragmentFetchAMD: return "OpFragmentFetchAMD";
     case OpReadClockKHR: return "OpReadClockKHR";
-    case OpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX";
+    case OpAllocateNodePayloadsAMDX: return "OpAllocateNodePayloadsAMDX";
+    case OpEnqueueNodePayloadsAMDX: return "OpEnqueueNodePayloadsAMDX";
+    case OpTypeNodePayloadArrayAMDX: return "OpTypeNodePayloadArrayAMDX";
     case OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX";
-    case OpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX";
+    case OpNodePayloadArrayLengthAMDX: return "OpNodePayloadArrayLengthAMDX";
+    case OpIsNodePayloadValidAMDX: return "OpIsNodePayloadValidAMDX";
+    case OpConstantStringAMDX: return "OpConstantStringAMDX";
+    case OpSpecConstantStringAMDX: return "OpSpecConstantStringAMDX";
     case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
     case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
     case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV";
@@ -4433,12 +4745,20 @@ inline const char* OpToString(Op value) {
     case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
     case OpTypeHitObjectNV: return "OpTypeHitObjectNV";
     case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
+    case OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV";
+    case OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV";
+    case OpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV";
+    case OpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV";
+    case OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
+    case OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV";
     case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
     case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
     case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV";
     case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
     case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
     case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
+    case OpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV";
+    case OpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV";
     case OpReportIntersectionKHR: return "OpReportIntersectionKHR";
     case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV";
     case OpTerminateRayNV: return "OpTerminateRayNV";
@@ -4448,6 +4768,8 @@ inline const char* OpToString(Op value) {
     case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
     case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR";
     case OpExecuteCallableNV: return "OpExecuteCallableNV";
+    case OpRayQueryGetClusterIdNV: return "OpRayQueryGetClusterIdNV";
+    case OpHitObjectGetClusterIdNV: return "OpHitObjectGetClusterIdNV";
     case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV";
     case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV";
     case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV";
@@ -4455,8 +4777,25 @@ inline const char* OpToString(Op value) {
     case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV";
     case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
     case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
+    case OpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV";
+    case OpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV";
+    case OpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV";
+    case OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
+    case OpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV";
+    case OpTypeTensorViewNV: return "OpTypeTensorViewNV";
+    case OpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV";
+    case OpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV";
+    case OpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV";
+    case OpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV";
+    case OpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV";
+    case OpCreateTensorViewNV: return "OpCreateTensorViewNV";
+    case OpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV";
+    case OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV";
     case OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation";
     case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT";
+    case OpTensorViewSetClipNV: return "OpTensorViewSetClipNV";
+    case OpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV";
+    case OpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV";
     case OpConvertUToImageNV: return "OpConvertUToImageNV";
     case OpConvertUToSamplerNV: return "OpConvertUToSamplerNV";
     case OpConvertImageToUNV: return "OpConvertImageToUNV";
@@ -4465,6 +4804,19 @@ inline const char* OpToString(Op value) {
     case OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV";
     case OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV";
     case OpRawAccessChainNV: return "OpRawAccessChainNV";
+    case OpRayQueryGetIntersectionSpherePositionNV: return "OpRayQueryGetIntersectionSpherePositionNV";
+    case OpRayQueryGetIntersectionSphereRadiusNV: return "OpRayQueryGetIntersectionSphereRadiusNV";
+    case OpRayQueryGetIntersectionLSSPositionsNV: return "OpRayQueryGetIntersectionLSSPositionsNV";
+    case OpRayQueryGetIntersectionLSSRadiiNV: return "OpRayQueryGetIntersectionLSSRadiiNV";
+    case OpRayQueryGetIntersectionLSSHitValueNV: return "OpRayQueryGetIntersectionLSSHitValueNV";
+    case OpHitObjectGetSpherePositionNV: return "OpHitObjectGetSpherePositionNV";
+    case OpHitObjectGetSphereRadiusNV: return "OpHitObjectGetSphereRadiusNV";
+    case OpHitObjectGetLSSPositionsNV: return "OpHitObjectGetLSSPositionsNV";
+    case OpHitObjectGetLSSRadiiNV: return "OpHitObjectGetLSSRadiiNV";
+    case OpHitObjectIsSphereHitNV: return "OpHitObjectIsSphereHitNV";
+    case OpHitObjectIsLSSHitNV: return "OpHitObjectIsLSSHitNV";
+    case OpRayQueryIsSphereHitNV: return "OpRayQueryIsSphereHitNV";
+    case OpRayQueryIsLSSHitNV: return "OpRayQueryIsLSSHitNV";
     case OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL";
     case OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL";
     case OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL";
@@ -4709,7 +5061,14 @@ inline const char* OpToString(Op value) {
     case OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL";
     case OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL";
     case OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL";
+    case OpArithmeticFenceEXT: return "OpArithmeticFenceEXT";
     case OpSubgroupBlockPrefetchINTEL: return "OpSubgroupBlockPrefetchINTEL";
+    case OpSubgroup2DBlockLoadINTEL: return "OpSubgroup2DBlockLoadINTEL";
+    case OpSubgroup2DBlockLoadTransformINTEL: return "OpSubgroup2DBlockLoadTransformINTEL";
+    case OpSubgroup2DBlockLoadTransposeINTEL: return "OpSubgroup2DBlockLoadTransposeINTEL";
+    case OpSubgroup2DBlockPrefetchINTEL: return "OpSubgroup2DBlockPrefetchINTEL";
+    case OpSubgroup2DBlockStoreINTEL: return "OpSubgroup2DBlockStoreINTEL";
+    case OpSubgroupMatrixMultiplyAccumulateINTEL: return "OpSubgroupMatrixMultiplyAccumulateINTEL";
     case OpGroupIMulKHR: return "OpGroupIMulKHR";
     case OpGroupFMulKHR: return "OpGroupFMulKHR";
     case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR";
@@ -4772,6 +5131,18 @@ inline CooperativeMatrixOperandsMask operator|(CooperativeMatrixOperandsMask a,
 inline CooperativeMatrixOperandsMask operator&(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) & unsigned(b)); }
 inline CooperativeMatrixOperandsMask operator^(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) ^ unsigned(b)); }
 inline CooperativeMatrixOperandsMask operator~(CooperativeMatrixOperandsMask a) { return CooperativeMatrixOperandsMask(~unsigned(a)); }
+inline CooperativeMatrixReduceMask operator|(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) | unsigned(b)); }
+inline CooperativeMatrixReduceMask operator&(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) & unsigned(b)); }
+inline CooperativeMatrixReduceMask operator^(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) ^ unsigned(b)); }
+inline CooperativeMatrixReduceMask operator~(CooperativeMatrixReduceMask a) { return CooperativeMatrixReduceMask(~unsigned(a)); }
+inline TensorAddressingOperandsMask operator|(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) | unsigned(b)); }
+inline TensorAddressingOperandsMask operator&(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) & unsigned(b)); }
+inline TensorAddressingOperandsMask operator^(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) ^ unsigned(b)); }
+inline TensorAddressingOperandsMask operator~(TensorAddressingOperandsMask a) { return TensorAddressingOperandsMask(~unsigned(a)); }
+inline MatrixMultiplyAccumulateOperandsMask operator|(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) | unsigned(b)); }
+inline MatrixMultiplyAccumulateOperandsMask operator&(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) & unsigned(b)); }
+inline MatrixMultiplyAccumulateOperandsMask operator^(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) ^ unsigned(b)); }
+inline MatrixMultiplyAccumulateOperandsMask operator~(MatrixMultiplyAccumulateOperandsMask a) { return MatrixMultiplyAccumulateOperandsMask(~unsigned(a)); }
 inline RawAccessChainOperandsMask operator|(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) | unsigned(b)); }
 inline RawAccessChainOperandsMask operator&(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) & unsigned(b)); }
 inline RawAccessChainOperandsMask operator^(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) ^ unsigned(b)); }

include/vulkan/spirv-headers/spirv.json

@@ -80,7 +80,8 @@
                     "NZSL": 9,
                     "WGSL": 10,
                     "Slang": 11,
-                    "Zig": 12
+                    "Zig": 12,
+                    "Rust": 13
                 }
             },
             {
@@ -193,6 +194,7 @@
                     "EarlyAndLateFragmentTestsAMD": 5017,
                     "StencilRefReplacingEXT": 5027,
                     "CoalescingAMDX": 5069,
+                    "IsApiEntryAMDX": 5070,
                     "MaxNodeRecursionAMDX": 5071,
                     "StaticNumWorkgroupsAMDX": 5072,
                     "ShaderIndexAMDX": 5073,
@@ -205,6 +207,7 @@
                     "StencilRefLessBackAMD": 5084,
                     "QuadDerivativesKHR": 5088,
                     "RequireFullQuadsKHR": 5089,
+                    "SharesInputWithAMDX": 5102,
                     "OutputLinesEXT": 5269,
                     "OutputLinesNV": 5269,
                     "OutputPrimitivesEXT": 5270,
@@ -261,7 +264,6 @@
                     "StorageBuffer": 12,
                     "TileImageEXT": 4172,
                     "NodePayloadAMDX": 5068,
-                    "NodeOutputPayloadAMDX": 5076,
                     "CallableDataKHR": 5328,
                     "CallableDataNV": 5328,
                     "IncomingCallableDataKHR": 5329,
@@ -575,6 +577,10 @@
                     "NodeMaxPayloadsAMDX": 5020,
                     "TrackFinishWritingAMDX": 5078,
                     "PayloadNodeNameAMDX": 5091,
+                    "PayloadNodeBaseIndexAMDX": 5098,
+                    "PayloadNodeSparseArrayAMDX": 5099,
+                    "PayloadNodeArraySizeAMDX": 5100,
+                    "PayloadDispatchIndirectAMDX": 5105,
                     "OverrideCoverageNV": 5248,
                     "PassthroughNV": 5250,
                     "ViewportRelativeNV": 5252,
@@ -741,7 +747,7 @@
                     "BaryCoordSmoothSampleAMD": 4997,
                     "BaryCoordPullModelAMD": 4998,
                     "FragStencilRefEXT": 5014,
-                    "CoalescedInputCountAMDX": 5021,
+                    "RemainingRecursionLevelsAMDX": 5021,
                     "ShaderIndexAMDX": 5073,
                     "ViewportMaskNV": 5253,
                     "SecondaryPositionNV": 5257,
@@ -801,12 +807,19 @@
                     "IncomingRayFlagsKHR": 5351,
                     "IncomingRayFlagsNV": 5351,
                     "RayGeometryIndexKHR": 5352,
+                    "HitIsSphereNV": 5359,
+                    "HitIsLSSNV": 5360,
+                    "HitSpherePositionNV": 5361,
                     "WarpsPerSMNV": 5374,
                     "SMCountNV": 5375,
                     "WarpIDNV": 5376,
                     "SMIDNV": 5377,
+                    "HitLSSPositionsNV": 5396,
                     "HitKindFrontFacingMicroTriangleNV": 5405,
                     "HitKindBackFacingMicroTriangleNV": 5406,
+                    "HitSphereRadiusNV": 5420,
+                    "HitLSSRadiiNV": 5421,
+                    "ClusterIDNV": 5436,
                     "CullMaskKHR": 6021
                 }
             },
@@ -854,6 +867,7 @@
                     "DontInline": 1,
                     "Pure": 2,
                     "Const": 3,
+                    "OptNoneEXT": 16,
                     "OptNoneINTEL": 16
                 }
             },
@@ -1137,9 +1151,20 @@
                     "ShaderInvocationReorderNV": 5383,
                     "BindlessTextureNV": 5390,
                     "RayQueryPositionFetchKHR": 5391,
+                    "CooperativeVectorNV": 5394,
                     "AtomicFloat16VectorNV": 5404,
                     "RayTracingDisplacementMicromapNV": 5409,
                     "RawAccessChainsNV": 5414,
+                    "RayTracingSpheresGeometryNV": 5418,
+                    "RayTracingLinearSweptSpheresGeometryNV": 5419,
+                    "CooperativeMatrixReductionsNV": 5430,
+                    "CooperativeMatrixConversionsNV": 5431,
+                    "CooperativeMatrixPerElementOperationsNV": 5432,
+                    "CooperativeMatrixTensorAddressingNV": 5433,
+                    "CooperativeMatrixBlockLoadsNV": 5434,
+                    "CooperativeVectorTrainingNV": 5435,
+                    "RayTracingClusterAccelerationStructureNV": 5437,
+                    "TensorAddressingNV": 5439,
                     "SubgroupShuffleINTEL": 5568,
                     "SubgroupBufferBlockIOINTEL": 5569,
                     "SubgroupImageBlockIOINTEL": 5570,
@@ -1199,11 +1224,13 @@
                     "AtomicFloat32AddEXT": 6033,
                     "AtomicFloat64AddEXT": 6034,
                     "LongCompositesINTEL": 6089,
+                    "OptNoneEXT": 6094,
                     "OptNoneINTEL": 6094,
                     "AtomicFloat16AddEXT": 6095,
                     "DebugInfoModuleINTEL": 6114,
                     "BFloat16ConversionINTEL": 6115,
                     "SplitBarrierINTEL": 6141,
+                    "ArithmeticFenceEXT": 6144,
                     "FPGAClusterAttributesV2INTEL": 6150,
                     "FPGAKernelAttributesv2INTEL": 6161,
                     "FPMaxErrorINTEL": 6169,
@@ -1212,6 +1239,10 @@
                     "GlobalVariableHostAccessINTEL": 6187,
                     "GlobalVariableFPGADecorationsINTEL": 6189,
                     "SubgroupBufferPrefetchINTEL": 6220,
+                    "Subgroup2DBlockIOINTEL": 6228,
+                    "Subgroup2DBlockTransformINTEL": 6229,
+                    "Subgroup2DBlockTransposeINTEL": 6230,
+                    "SubgroupMatrixMultiplyAccumulateINTEL": 6236,
                     "GroupUniformArithmeticKHR": 6400,
                     "MaskedGatherScatterINTEL": 6427,
                     "CacheControlsINTEL": 6441,
@@ -1231,6 +1262,7 @@
                     "CullFrontFacingTrianglesKHR": 5,
                     "CullOpaqueKHR": 6,
                     "CullNoOpaqueKHR": 7,
+                    "SkipBuiltinPrimitivesNV": 8,
                     "SkipTrianglesKHR": 8,
                     "SkipAABBsKHR": 9,
                     "ForceOpacityMicromap2StateEXT": 10
@@ -1361,6 +1393,37 @@
                     "MatrixAccumulatorKHR": 2
                 }
             },
+            {
+                "Name": "CooperativeMatrixReduce",
+                "Type": "Bit",
+                "Values":
+                {
+                    "Row": 0,
+                    "Column": 1,
+                    "CooperativeMatrixReduce2x2": 2
+                }
+            },
+            {
+                "Name": "TensorClampMode",
+                "Type": "Value",
+                "Values":
+                {
+                    "Undefined": 0,
+                    "Constant": 1,
+                    "ClampToEdge": 2,
+                    "Repeat": 3,
+                    "RepeatMirrored": 4
+                }
+            },
+            {
+                "Name": "TensorAddressingOperands",
+                "Type": "Bit",
+                "Values":
+                {
+                    "TensorView": 0,
+                    "DecodeFunc": 1
+                }
+            },
             {
                 "Name": "InitializationModeQualifier",
                 "Type": "Value",
@@ -1412,6 +1475,27 @@
                     "AutoINTEL": 0
                 }
             },
+            {
+                "Name": "MatrixMultiplyAccumulateOperands",
+                "Type": "Bit",
+                "Values":
+                {
+                    "MatrixASignedComponentsINTEL": 0,
+                    "MatrixBSignedComponentsINTEL": 1,
+                    "MatrixCBFloat16INTEL": 2,
+                    "MatrixResultBFloat16INTEL": 3,
+                    "MatrixAPackedInt8INTEL": 4,
+                    "MatrixBPackedInt8INTEL": 5,
+                    "MatrixAPackedInt4INTEL": 6,
+                    "MatrixBPackedInt4INTEL": 7,
+                    "MatrixATF32INTEL": 8,
+                    "MatrixBTF32INTEL": 9,
+                    "MatrixAPackedFloat16INTEL": 10,
+                    "MatrixBPackedFloat16INTEL": 11,
+                    "MatrixAPackedBFloat16INTEL": 12,
+                    "MatrixBPackedBFloat16INTEL": 13
+                }
+            },
             {
                 "Name": "RawAccessChainOperands",
                 "Type": "Bit",
@@ -1428,6 +1512,39 @@
                 {
                 }
             },
+            {
+                "Name": "CooperativeVectorMatrixLayout",
+                "Type": "Value",
+                "Values":
+                {
+                    "RowMajorNV": 0,
+                    "ColumnMajorNV": 1,
+                    "InferencingOptimalNV": 2,
+                    "TrainingOptimalNV": 3
+                }
+            },
+            {
+                "Name": "ComponentType",
+                "Type": "Value",
+                "Values":
+                {
+                    "Float16NV": 0,
+                    "Float32NV": 1,
+                    "Float64NV": 2,
+                    "SignedInt8NV": 3,
+                    "SignedInt16NV": 4,
+                    "SignedInt32NV": 5,
+                    "SignedInt64NV": 6,
+                    "UnsignedInt8NV": 7,
+                    "UnsignedInt16NV": 8,
+                    "UnsignedInt32NV": 9,
+                    "UnsignedInt64NV": 10,
+                    "SignedInt8PackedNV": 1000491000,
+                    "UnsignedInt8PackedNV": 1000491001,
+                    "FloatE4M3NV": 1000491002,
+                    "FloatE5M2NV": 1000491003
+                }
+            },
             {
                 "Name": "Op",
                 "Type": "Value",
@@ -1848,9 +1965,14 @@
                     "OpFragmentMaskFetchAMD": 5011,
                     "OpFragmentFetchAMD": 5012,
                     "OpReadClockKHR": 5056,
-                    "OpFinalizeNodePayloadsAMDX": 5075,
+                    "OpAllocateNodePayloadsAMDX": 5074,
+                    "OpEnqueueNodePayloadsAMDX": 5075,
+                    "OpTypeNodePayloadArrayAMDX": 5076,
                     "OpFinishWritingNodePayloadAMDX": 5078,
-                    "OpInitializeNodePayloadsAMDX": 5090,
+                    "OpNodePayloadArrayLengthAMDX": 5090,
+                    "OpIsNodePayloadValidAMDX": 5101,
+                    "OpConstantStringAMDX": 5103,
+                    "OpSpecConstantStringAMDX": 5104,
                     "OpGroupNonUniformQuadAllKHR": 5110,
                     "OpGroupNonUniformQuadAnyKHR": 5111,
                     "OpHitObjectRecordHitMotionNV": 5249,
@@ -1887,12 +2009,20 @@
                     "OpReorderThreadWithHintNV": 5280,
                     "OpTypeHitObjectNV": 5281,
                     "OpImageSampleFootprintNV": 5283,
+                    "OpTypeCooperativeVectorNV": 5288,
+                    "OpCooperativeVectorMatrixMulNV": 5289,
+                    "OpCooperativeVectorOuterProductAccumulateNV": 5290,
+                    "OpCooperativeVectorReduceSumAccumulateNV": 5291,
+                    "OpCooperativeVectorMatrixMulAddNV": 5292,
+                    "OpCooperativeMatrixConvertNV": 5293,
                     "OpEmitMeshTasksEXT": 5294,
                     "OpSetMeshOutputsEXT": 5295,
                     "OpGroupNonUniformPartitionNV": 5296,
                     "OpWritePackedPrimitiveIndices4x8NV": 5299,
                     "OpFetchMicroTriangleVertexPositionNV": 5300,
                     "OpFetchMicroTriangleVertexBarycentricNV": 5301,
+                    "OpCooperativeVectorLoadNV": 5302,
+                    "OpCooperativeVectorStoreNV": 5303,
                     "OpReportIntersectionKHR": 5334,
                     "OpReportIntersectionNV": 5334,
                     "OpIgnoreIntersectionNV": 5335,
@@ -1904,6 +2034,8 @@
                     "OpTypeAccelerationStructureKHR": 5341,
                     "OpTypeAccelerationStructureNV": 5341,
                     "OpExecuteCallableNV": 5344,
+                    "OpRayQueryGetClusterIdNV": 5345,
+                    "OpHitObjectGetClusterIdNV": 5346,
                     "OpTypeCooperativeMatrixNV": 5358,
                     "OpCooperativeMatrixLoadNV": 5359,
                     "OpCooperativeMatrixStoreNV": 5360,
@@ -1911,9 +2043,26 @@
                     "OpCooperativeMatrixLengthNV": 5362,
                     "OpBeginInvocationInterlockEXT": 5364,
                     "OpEndInvocationInterlockEXT": 5365,
+                    "OpCooperativeMatrixReduceNV": 5366,
+                    "OpCooperativeMatrixLoadTensorNV": 5367,
+                    "OpCooperativeMatrixStoreTensorNV": 5368,
+                    "OpCooperativeMatrixPerElementOpNV": 5369,
+                    "OpTypeTensorLayoutNV": 5370,
+                    "OpTypeTensorViewNV": 5371,
+                    "OpCreateTensorLayoutNV": 5372,
+                    "OpTensorLayoutSetDimensionNV": 5373,
+                    "OpTensorLayoutSetStrideNV": 5374,
+                    "OpTensorLayoutSliceNV": 5375,
+                    "OpTensorLayoutSetClampValueNV": 5376,
+                    "OpCreateTensorViewNV": 5377,
+                    "OpTensorViewSetDimensionNV": 5378,
+                    "OpTensorViewSetStrideNV": 5379,
                     "OpDemoteToHelperInvocation": 5380,
                     "OpDemoteToHelperInvocationEXT": 5380,
                     "OpIsHelperInvocationEXT": 5381,
+                    "OpTensorViewSetClipNV": 5382,
+                    "OpTensorLayoutSetBlockSizeNV": 5384,
+                    "OpCooperativeMatrixTransposeNV": 5390,
                     "OpConvertUToImageNV": 5391,
                     "OpConvertUToSamplerNV": 5392,
                     "OpConvertImageToUNV": 5393,
@@ -1922,6 +2071,19 @@
                     "OpConvertSampledImageToUNV": 5396,
                     "OpSamplerImageAddressingModeNV": 5397,
                     "OpRawAccessChainNV": 5398,
+                    "OpRayQueryGetIntersectionSpherePositionNV": 5427,
+                    "OpRayQueryGetIntersectionSphereRadiusNV": 5428,
+                    "OpRayQueryGetIntersectionLSSPositionsNV": 5429,
+                    "OpRayQueryGetIntersectionLSSRadiiNV": 5430,
+                    "OpRayQueryGetIntersectionLSSHitValueNV": 5431,
+                    "OpHitObjectGetSpherePositionNV": 5432,
+                    "OpHitObjectGetSphereRadiusNV": 5433,
+                    "OpHitObjectGetLSSPositionsNV": 5434,
+                    "OpHitObjectGetLSSRadiiNV": 5435,
+                    "OpHitObjectIsSphereHitNV": 5436,
+                    "OpHitObjectIsLSSHitNV": 5437,
+                    "OpRayQueryIsSphereHitNV": 5438,
+                    "OpRayQueryIsLSSHitNV": 5439,
                     "OpSubgroupShuffleINTEL": 5571,
                     "OpSubgroupShuffleDownINTEL": 5572,
                     "OpSubgroupShuffleUpINTEL": 5573,
@@ -2168,7 +2330,14 @@
                     "OpConvertBF16ToFINTEL": 6117,
                     "OpControlBarrierArriveINTEL": 6142,
                     "OpControlBarrierWaitINTEL": 6143,
+                    "OpArithmeticFenceEXT": 6145,
                     "OpSubgroupBlockPrefetchINTEL": 6221,
+                    "OpSubgroup2DBlockLoadINTEL": 6231,
+                    "OpSubgroup2DBlockLoadTransformINTEL": 6232,
+                    "OpSubgroup2DBlockLoadTransposeINTEL": 6233,
+                    "OpSubgroup2DBlockPrefetchINTEL": 6234,
+                    "OpSubgroup2DBlockStoreINTEL": 6235,
+                    "OpSubgroupMatrixMultiplyAccumulateINTEL": 6237,
                     "OpGroupIMulKHR": 6401,
                     "OpGroupFMulKHR": 6402,
                     "OpGroupBitwiseAndKHR": 6403,

include/vulkan/spirv-headers/spirv.lua

@@ -65,6 +65,7 @@ spv = {
         WGSL = 10,
         Slang = 11,
         Zig = 12,
+        Rust = 13,
         Max = 0x7fffffff,
     },
 
@@ -165,6 +166,7 @@ spv = {
         EarlyAndLateFragmentTestsAMD = 5017,
         StencilRefReplacingEXT = 5027,
         CoalescingAMDX = 5069,
+        IsApiEntryAMDX = 5070,
         MaxNodeRecursionAMDX = 5071,
         StaticNumWorkgroupsAMDX = 5072,
         ShaderIndexAMDX = 5073,
@@ -177,6 +179,7 @@ spv = {
         StencilRefLessBackAMD = 5084,
         QuadDerivativesKHR = 5088,
         RequireFullQuadsKHR = 5089,
+        SharesInputWithAMDX = 5102,
         OutputLinesEXT = 5269,
         OutputLinesNV = 5269,
         OutputPrimitivesEXT = 5270,
@@ -230,7 +233,6 @@ spv = {
         StorageBuffer = 12,
         TileImageEXT = 4172,
         NodePayloadAMDX = 5068,
-        NodeOutputPayloadAMDX = 5076,
         CallableDataKHR = 5328,
         CallableDataNV = 5328,
         IncomingCallableDataKHR = 5329,
@@ -543,6 +545,10 @@ spv = {
         NodeMaxPayloadsAMDX = 5020,
         TrackFinishWritingAMDX = 5078,
         PayloadNodeNameAMDX = 5091,
+        PayloadNodeBaseIndexAMDX = 5098,
+        PayloadNodeSparseArrayAMDX = 5099,
+        PayloadNodeArraySizeAMDX = 5100,
+        PayloadDispatchIndirectAMDX = 5105,
         OverrideCoverageNV = 5248,
         PassthroughNV = 5250,
         ViewportRelativeNV = 5252,
@@ -706,7 +712,7 @@ spv = {
         BaryCoordSmoothSampleAMD = 4997,
         BaryCoordPullModelAMD = 4998,
         FragStencilRefEXT = 5014,
-        CoalescedInputCountAMDX = 5021,
+        RemainingRecursionLevelsAMDX = 5021,
         ShaderIndexAMDX = 5073,
         ViewportMaskNV = 5253,
         SecondaryPositionNV = 5257,
@@ -766,12 +772,19 @@ spv = {
         IncomingRayFlagsKHR = 5351,
         IncomingRayFlagsNV = 5351,
         RayGeometryIndexKHR = 5352,
+        HitIsSphereNV = 5359,
+        HitIsLSSNV = 5360,
+        HitSpherePositionNV = 5361,
         WarpsPerSMNV = 5374,
         SMCountNV = 5375,
         WarpIDNV = 5376,
         SMIDNV = 5377,
+        HitLSSPositionsNV = 5396,
         HitKindFrontFacingMicroTriangleNV = 5405,
         HitKindBackFacingMicroTriangleNV = 5406,
+        HitSphereRadiusNV = 5420,
+        HitLSSRadiiNV = 5421,
+        ClusterIDNV = 5436,
         CullMaskKHR = 6021,
         Max = 0x7fffffff,
     },
@@ -839,6 +852,7 @@ spv = {
         DontInline = 1,
         Pure = 2,
         Const = 3,
+        OptNoneEXT = 16,
         OptNoneINTEL = 16,
         Max = 0x7fffffff,
     },
@@ -849,6 +863,7 @@ spv = {
         DontInline = 0x00000002,
         Pure = 0x00000004,
         Const = 0x00000008,
+        OptNoneEXT = 0x00010000,
         OptNoneINTEL = 0x00010000,
     },
 
@@ -1151,9 +1166,20 @@ spv = {
         ShaderInvocationReorderNV = 5383,
         BindlessTextureNV = 5390,
         RayQueryPositionFetchKHR = 5391,
+        CooperativeVectorNV = 5394,
         AtomicFloat16VectorNV = 5404,
         RayTracingDisplacementMicromapNV = 5409,
         RawAccessChainsNV = 5414,
+        RayTracingSpheresGeometryNV = 5418,
+        RayTracingLinearSweptSpheresGeometryNV = 5419,
+        CooperativeMatrixReductionsNV = 5430,
+        CooperativeMatrixConversionsNV = 5431,
+        CooperativeMatrixPerElementOperationsNV = 5432,
+        CooperativeMatrixTensorAddressingNV = 5433,
+        CooperativeMatrixBlockLoadsNV = 5434,
+        CooperativeVectorTrainingNV = 5435,
+        RayTracingClusterAccelerationStructureNV = 5437,
+        TensorAddressingNV = 5439,
         SubgroupShuffleINTEL = 5568,
         SubgroupBufferBlockIOINTEL = 5569,
         SubgroupImageBlockIOINTEL = 5570,
@@ -1213,11 +1239,13 @@ spv = {
         AtomicFloat32AddEXT = 6033,
         AtomicFloat64AddEXT = 6034,
         LongCompositesINTEL = 6089,
+        OptNoneEXT = 6094,
         OptNoneINTEL = 6094,
         AtomicFloat16AddEXT = 6095,
         DebugInfoModuleINTEL = 6114,
         BFloat16ConversionINTEL = 6115,
         SplitBarrierINTEL = 6141,
+        ArithmeticFenceEXT = 6144,
         FPGAClusterAttributesV2INTEL = 6150,
         FPGAKernelAttributesv2INTEL = 6161,
         FPMaxErrorINTEL = 6169,
@@ -1226,6 +1254,10 @@ spv = {
         GlobalVariableHostAccessINTEL = 6187,
         GlobalVariableFPGADecorationsINTEL = 6189,
         SubgroupBufferPrefetchINTEL = 6220,
+        Subgroup2DBlockIOINTEL = 6228,
+        Subgroup2DBlockTransformINTEL = 6229,
+        Subgroup2DBlockTransposeINTEL = 6230,
+        SubgroupMatrixMultiplyAccumulateINTEL = 6236,
         GroupUniformArithmeticKHR = 6400,
         MaskedGatherScatterINTEL = 6427,
         CacheControlsINTEL = 6441,
@@ -1242,6 +1274,7 @@ spv = {
         CullFrontFacingTrianglesKHR = 5,
         CullOpaqueKHR = 6,
         CullNoOpaqueKHR = 7,
+        SkipBuiltinPrimitivesNV = 8,
         SkipTrianglesKHR = 8,
         SkipAABBsKHR = 9,
         ForceOpacityMicromap2StateEXT = 10,
@@ -1258,6 +1291,7 @@ spv = {
         CullFrontFacingTrianglesKHR = 0x00000020,
         CullOpaqueKHR = 0x00000040,
         CullNoOpaqueKHR = 0x00000080,
+        SkipBuiltinPrimitivesNV = 0x00000100,
         SkipTrianglesKHR = 0x00000100,
         SkipAABBsKHR = 0x00000200,
         ForceOpacityMicromap2StateEXT = 0x00000400,
@@ -1369,6 +1403,41 @@ spv = {
         Max = 0x7fffffff,
     },
 
+    CooperativeMatrixReduceShift = {
+        Row = 0,
+        Column = 1,
+        CooperativeMatrixReduce2x2 = 2,
+        Max = 0x7fffffff,
+    },
+
+    CooperativeMatrixReduceMask = {
+        MaskNone = 0,
+        Row = 0x00000001,
+        Column = 0x00000002,
+        CooperativeMatrixReduce2x2 = 0x00000004,
+    },
+
+    TensorClampMode = {
+        Undefined = 0,
+        Constant = 1,
+        ClampToEdge = 2,
+        Repeat = 3,
+        RepeatMirrored = 4,
+        Max = 0x7fffffff,
+    },
+
+    TensorAddressingOperandsShift = {
+        TensorView = 0,
+        DecodeFunc = 1,
+        Max = 0x7fffffff,
+    },
+
+    TensorAddressingOperandsMask = {
+        MaskNone = 0,
+        TensorView = 0x00000001,
+        DecodeFunc = 0x00000002,
+    },
+
     InitializationModeQualifier = {
         InitOnDeviceReprogramINTEL = 0,
         InitOnDeviceResetINTEL = 1,
@@ -1405,6 +1474,42 @@ spv = {
         Max = 0x7fffffff,
     },
 
+    MatrixMultiplyAccumulateOperandsShift = {
+        MatrixASignedComponentsINTEL = 0,
+        MatrixBSignedComponentsINTEL = 1,
+        MatrixCBFloat16INTEL = 2,
+        MatrixResultBFloat16INTEL = 3,
+        MatrixAPackedInt8INTEL = 4,
+        MatrixBPackedInt8INTEL = 5,
+        MatrixAPackedInt4INTEL = 6,
+        MatrixBPackedInt4INTEL = 7,
+        MatrixATF32INTEL = 8,
+        MatrixBTF32INTEL = 9,
+        MatrixAPackedFloat16INTEL = 10,
+        MatrixBPackedFloat16INTEL = 11,
+        MatrixAPackedBFloat16INTEL = 12,
+        MatrixBPackedBFloat16INTEL = 13,
+        Max = 0x7fffffff,
+    },
+
+    MatrixMultiplyAccumulateOperandsMask = {
+        MaskNone = 0,
+        MatrixASignedComponentsINTEL = 0x00000001,
+        MatrixBSignedComponentsINTEL = 0x00000002,
+        MatrixCBFloat16INTEL = 0x00000004,
+        MatrixResultBFloat16INTEL = 0x00000008,
+        MatrixAPackedInt8INTEL = 0x00000010,
+        MatrixBPackedInt8INTEL = 0x00000020,
+        MatrixAPackedInt4INTEL = 0x00000040,
+        MatrixBPackedInt4INTEL = 0x00000080,
+        MatrixATF32INTEL = 0x00000100,
+        MatrixBTF32INTEL = 0x00000200,
+        MatrixAPackedFloat16INTEL = 0x00000400,
+        MatrixBPackedFloat16INTEL = 0x00000800,
+        MatrixAPackedBFloat16INTEL = 0x00001000,
+        MatrixBPackedBFloat16INTEL = 0x00002000,
+    },
+
     RawAccessChainOperandsShift = {
         RobustnessPerComponentNV = 0,
         RobustnessPerElementNV = 1,
@@ -1421,6 +1526,33 @@ spv = {
         Max = 0x7fffffff,
     },
 
+    CooperativeVectorMatrixLayout = {
+        RowMajorNV = 0,
+        ColumnMajorNV = 1,
+        InferencingOptimalNV = 2,
+        TrainingOptimalNV = 3,
+        Max = 0x7fffffff,
+    },
+
+    ComponentType = {
+        Float16NV = 0,
+        Float32NV = 1,
+        Float64NV = 2,
+        SignedInt8NV = 3,
+        SignedInt16NV = 4,
+        SignedInt32NV = 5,
+        SignedInt64NV = 6,
+        UnsignedInt8NV = 7,
+        UnsignedInt16NV = 8,
+        UnsignedInt32NV = 9,
+        UnsignedInt64NV = 10,
+        SignedInt8PackedNV = 1000491000,
+        UnsignedInt8PackedNV = 1000491001,
+        FloatE4M3NV = 1000491002,
+        FloatE5M2NV = 1000491003,
+        Max = 0x7fffffff,
+    },
+
     Op = {
         OpNop = 0,
         OpUndef = 1,
@@ -1837,9 +1969,14 @@ spv = {
         OpFragmentMaskFetchAMD = 5011,
         OpFragmentFetchAMD = 5012,
         OpReadClockKHR = 5056,
-        OpFinalizeNodePayloadsAMDX = 5075,
+        OpAllocateNodePayloadsAMDX = 5074,
+        OpEnqueueNodePayloadsAMDX = 5075,
+        OpTypeNodePayloadArrayAMDX = 5076,
         OpFinishWritingNodePayloadAMDX = 5078,
-        OpInitializeNodePayloadsAMDX = 5090,
+        OpNodePayloadArrayLengthAMDX = 5090,
+        OpIsNodePayloadValidAMDX = 5101,
+        OpConstantStringAMDX = 5103,
+        OpSpecConstantStringAMDX = 5104,
         OpGroupNonUniformQuadAllKHR = 5110,
         OpGroupNonUniformQuadAnyKHR = 5111,
         OpHitObjectRecordHitMotionNV = 5249,
@@ -1876,12 +2013,20 @@ spv = {
         OpReorderThreadWithHintNV = 5280,
         OpTypeHitObjectNV = 5281,
         OpImageSampleFootprintNV = 5283,
+        OpTypeCooperativeVectorNV = 5288,
+        OpCooperativeVectorMatrixMulNV = 5289,
+        OpCooperativeVectorOuterProductAccumulateNV = 5290,
+        OpCooperativeVectorReduceSumAccumulateNV = 5291,
+        OpCooperativeVectorMatrixMulAddNV = 5292,
+        OpCooperativeMatrixConvertNV = 5293,
         OpEmitMeshTasksEXT = 5294,
         OpSetMeshOutputsEXT = 5295,
         OpGroupNonUniformPartitionNV = 5296,
         OpWritePackedPrimitiveIndices4x8NV = 5299,
         OpFetchMicroTriangleVertexPositionNV = 5300,
         OpFetchMicroTriangleVertexBarycentricNV = 5301,
+        OpCooperativeVectorLoadNV = 5302,
+        OpCooperativeVectorStoreNV = 5303,
         OpReportIntersectionKHR = 5334,
         OpReportIntersectionNV = 5334,
         OpIgnoreIntersectionNV = 5335,
@@ -1893,6 +2038,8 @@ spv = {
         OpTypeAccelerationStructureKHR = 5341,
         OpTypeAccelerationStructureNV = 5341,
         OpExecuteCallableNV = 5344,
+        OpRayQueryGetClusterIdNV = 5345,
+        OpHitObjectGetClusterIdNV = 5346,
         OpTypeCooperativeMatrixNV = 5358,
         OpCooperativeMatrixLoadNV = 5359,
         OpCooperativeMatrixStoreNV = 5360,
@@ -1900,9 +2047,26 @@ spv = {
         OpCooperativeMatrixLengthNV = 5362,
         OpBeginInvocationInterlockEXT = 5364,
         OpEndInvocationInterlockEXT = 5365,
+        OpCooperativeMatrixReduceNV = 5366,
+        OpCooperativeMatrixLoadTensorNV = 5367,
+        OpCooperativeMatrixStoreTensorNV = 5368,
+        OpCooperativeMatrixPerElementOpNV = 5369,
+        OpTypeTensorLayoutNV = 5370,
+        OpTypeTensorViewNV = 5371,
+        OpCreateTensorLayoutNV = 5372,
+        OpTensorLayoutSetDimensionNV = 5373,
+        OpTensorLayoutSetStrideNV = 5374,
+        OpTensorLayoutSliceNV = 5375,
+        OpTensorLayoutSetClampValueNV = 5376,
+        OpCreateTensorViewNV = 5377,
+        OpTensorViewSetDimensionNV = 5378,
+        OpTensorViewSetStrideNV = 5379,
         OpDemoteToHelperInvocation = 5380,
         OpDemoteToHelperInvocationEXT = 5380,
         OpIsHelperInvocationEXT = 5381,
+        OpTensorViewSetClipNV = 5382,
+        OpTensorLayoutSetBlockSizeNV = 5384,
+        OpCooperativeMatrixTransposeNV = 5390,
         OpConvertUToImageNV = 5391,
         OpConvertUToSamplerNV = 5392,
         OpConvertImageToUNV = 5393,
@@ -1911,6 +2075,19 @@ spv = {
         OpConvertSampledImageToUNV = 5396,
         OpSamplerImageAddressingModeNV = 5397,
         OpRawAccessChainNV = 5398,
+        OpRayQueryGetIntersectionSpherePositionNV = 5427,
+        OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+        OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+        OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+        OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+        OpHitObjectGetSpherePositionNV = 5432,
+        OpHitObjectGetSphereRadiusNV = 5433,
+        OpHitObjectGetLSSPositionsNV = 5434,
+        OpHitObjectGetLSSRadiiNV = 5435,
+        OpHitObjectIsSphereHitNV = 5436,
+        OpHitObjectIsLSSHitNV = 5437,
+        OpRayQueryIsSphereHitNV = 5438,
+        OpRayQueryIsLSSHitNV = 5439,
         OpSubgroupShuffleINTEL = 5571,
         OpSubgroupShuffleDownINTEL = 5572,
         OpSubgroupShuffleUpINTEL = 5573,
@@ -2157,7 +2334,14 @@ spv = {
         OpConvertBF16ToFINTEL = 6117,
         OpControlBarrierArriveINTEL = 6142,
         OpControlBarrierWaitINTEL = 6143,
+        OpArithmeticFenceEXT = 6145,
         OpSubgroupBlockPrefetchINTEL = 6221,
+        OpSubgroup2DBlockLoadINTEL = 6231,
+        OpSubgroup2DBlockLoadTransformINTEL = 6232,
+        OpSubgroup2DBlockLoadTransposeINTEL = 6233,
+        OpSubgroup2DBlockPrefetchINTEL = 6234,
+        OpSubgroup2DBlockStoreINTEL = 6235,
+        OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
         OpGroupIMulKHR = 6401,
         OpGroupFMulKHR = 6402,
         OpGroupBitwiseAndKHR = 6403,

include/vulkan/spirv-headers/spirv.py

@@ -65,6 +65,7 @@ spv = {
         'WGSL' : 10,
         'Slang' : 11,
         'Zig' : 12,
+        'Rust' : 13,
     },
 
     'ExecutionModel' : {
@@ -161,6 +162,7 @@ spv = {
         'EarlyAndLateFragmentTestsAMD' : 5017,
         'StencilRefReplacingEXT' : 5027,
         'CoalescingAMDX' : 5069,
+        'IsApiEntryAMDX' : 5070,
         'MaxNodeRecursionAMDX' : 5071,
         'StaticNumWorkgroupsAMDX' : 5072,
         'ShaderIndexAMDX' : 5073,
@@ -173,6 +175,7 @@ spv = {
         'StencilRefLessBackAMD' : 5084,
         'QuadDerivativesKHR' : 5088,
         'RequireFullQuadsKHR' : 5089,
+        'SharesInputWithAMDX' : 5102,
         'OutputLinesEXT' : 5269,
         'OutputLinesNV' : 5269,
         'OutputPrimitivesEXT' : 5270,
@@ -225,7 +228,6 @@ spv = {
         'StorageBuffer' : 12,
         'TileImageEXT' : 4172,
         'NodePayloadAMDX' : 5068,
-        'NodeOutputPayloadAMDX' : 5076,
         'CallableDataKHR' : 5328,
         'CallableDataNV' : 5328,
         'IncomingCallableDataKHR' : 5329,
@@ -525,6 +527,10 @@ spv = {
         'NodeMaxPayloadsAMDX' : 5020,
         'TrackFinishWritingAMDX' : 5078,
         'PayloadNodeNameAMDX' : 5091,
+        'PayloadNodeBaseIndexAMDX' : 5098,
+        'PayloadNodeSparseArrayAMDX' : 5099,
+        'PayloadNodeArraySizeAMDX' : 5100,
+        'PayloadDispatchIndirectAMDX' : 5105,
         'OverrideCoverageNV' : 5248,
         'PassthroughNV' : 5250,
         'ViewportRelativeNV' : 5252,
@@ -687,7 +693,7 @@ spv = {
         'BaryCoordSmoothSampleAMD' : 4997,
         'BaryCoordPullModelAMD' : 4998,
         'FragStencilRefEXT' : 5014,
-        'CoalescedInputCountAMDX' : 5021,
+        'RemainingRecursionLevelsAMDX' : 5021,
         'ShaderIndexAMDX' : 5073,
         'ViewportMaskNV' : 5253,
         'SecondaryPositionNV' : 5257,
@@ -747,12 +753,19 @@ spv = {
         'IncomingRayFlagsKHR' : 5351,
         'IncomingRayFlagsNV' : 5351,
         'RayGeometryIndexKHR' : 5352,
+        'HitIsSphereNV' : 5359,
+        'HitIsLSSNV' : 5360,
+        'HitSpherePositionNV' : 5361,
         'WarpsPerSMNV' : 5374,
         'SMCountNV' : 5375,
         'WarpIDNV' : 5376,
         'SMIDNV' : 5377,
+        'HitLSSPositionsNV' : 5396,
         'HitKindFrontFacingMicroTriangleNV' : 5405,
         'HitKindBackFacingMicroTriangleNV' : 5406,
+        'HitSphereRadiusNV' : 5420,
+        'HitLSSRadiiNV' : 5421,
+        'ClusterIDNV' : 5436,
         'CullMaskKHR' : 6021,
     },
 
@@ -817,6 +830,7 @@ spv = {
         'DontInline' : 1,
         'Pure' : 2,
         'Const' : 3,
+        'OptNoneEXT' : 16,
         'OptNoneINTEL' : 16,
     },
 
@@ -826,6 +840,7 @@ spv = {
         'DontInline' : 0x00000002,
         'Pure' : 0x00000004,
         'Const' : 0x00000008,
+        'OptNoneEXT' : 0x00010000,
         'OptNoneINTEL' : 0x00010000,
     },
 
@@ -1122,9 +1137,20 @@ spv = {
         'ShaderInvocationReorderNV' : 5383,
         'BindlessTextureNV' : 5390,
         'RayQueryPositionFetchKHR' : 5391,
+        'CooperativeVectorNV' : 5394,
         'AtomicFloat16VectorNV' : 5404,
         'RayTracingDisplacementMicromapNV' : 5409,
         'RawAccessChainsNV' : 5414,
+        'RayTracingSpheresGeometryNV' : 5418,
+        'RayTracingLinearSweptSpheresGeometryNV' : 5419,
+        'CooperativeMatrixReductionsNV' : 5430,
+        'CooperativeMatrixConversionsNV' : 5431,
+        'CooperativeMatrixPerElementOperationsNV' : 5432,
+        'CooperativeMatrixTensorAddressingNV' : 5433,
+        'CooperativeMatrixBlockLoadsNV' : 5434,
+        'CooperativeVectorTrainingNV' : 5435,
+        'RayTracingClusterAccelerationStructureNV' : 5437,
+        'TensorAddressingNV' : 5439,
         'SubgroupShuffleINTEL' : 5568,
         'SubgroupBufferBlockIOINTEL' : 5569,
         'SubgroupImageBlockIOINTEL' : 5570,
@@ -1184,11 +1210,13 @@ spv = {
         'AtomicFloat32AddEXT' : 6033,
         'AtomicFloat64AddEXT' : 6034,
         'LongCompositesINTEL' : 6089,
+        'OptNoneEXT' : 6094,
         'OptNoneINTEL' : 6094,
         'AtomicFloat16AddEXT' : 6095,
         'DebugInfoModuleINTEL' : 6114,
         'BFloat16ConversionINTEL' : 6115,
         'SplitBarrierINTEL' : 6141,
+        'ArithmeticFenceEXT' : 6144,
         'FPGAClusterAttributesV2INTEL' : 6150,
         'FPGAKernelAttributesv2INTEL' : 6161,
         'FPMaxErrorINTEL' : 6169,
@@ -1197,6 +1225,10 @@ spv = {
         'GlobalVariableHostAccessINTEL' : 6187,
         'GlobalVariableFPGADecorationsINTEL' : 6189,
         'SubgroupBufferPrefetchINTEL' : 6220,
+        'Subgroup2DBlockIOINTEL' : 6228,
+        'Subgroup2DBlockTransformINTEL' : 6229,
+        'Subgroup2DBlockTransposeINTEL' : 6230,
+        'SubgroupMatrixMultiplyAccumulateINTEL' : 6236,
         'GroupUniformArithmeticKHR' : 6400,
         'MaskedGatherScatterINTEL' : 6427,
         'CacheControlsINTEL' : 6441,
@@ -1212,6 +1244,7 @@ spv = {
         'CullFrontFacingTrianglesKHR' : 5,
         'CullOpaqueKHR' : 6,
         'CullNoOpaqueKHR' : 7,
+        'SkipBuiltinPrimitivesNV' : 8,
         'SkipTrianglesKHR' : 8,
         'SkipAABBsKHR' : 9,
         'ForceOpacityMicromap2StateEXT' : 10,
@@ -1227,6 +1260,7 @@ spv = {
         'CullFrontFacingTrianglesKHR' : 0x00000020,
         'CullOpaqueKHR' : 0x00000040,
         'CullNoOpaqueKHR' : 0x00000080,
+        'SkipBuiltinPrimitivesNV' : 0x00000100,
         'SkipTrianglesKHR' : 0x00000100,
         'SkipAABBsKHR' : 0x00000200,
         'ForceOpacityMicromap2StateEXT' : 0x00000400,
@@ -1326,6 +1360,38 @@ spv = {
         'MatrixAccumulatorKHR' : 2,
     },
 
+    'CooperativeMatrixReduceShift' : {
+        'Row' : 0,
+        'Column' : 1,
+        'CooperativeMatrixReduce2x2' : 2,
+    },
+
+    'CooperativeMatrixReduceMask' : {
+        'MaskNone' : 0,
+        'Row' : 0x00000001,
+        'Column' : 0x00000002,
+        'CooperativeMatrixReduce2x2' : 0x00000004,
+    },
+
+    'TensorClampMode' : {
+        'Undefined' : 0,
+        'Constant' : 1,
+        'ClampToEdge' : 2,
+        'Repeat' : 3,
+        'RepeatMirrored' : 4,
+    },
+
+    'TensorAddressingOperandsShift' : {
+        'TensorView' : 0,
+        'DecodeFunc' : 1,
+    },
+
+    'TensorAddressingOperandsMask' : {
+        'MaskNone' : 0,
+        'TensorView' : 0x00000001,
+        'DecodeFunc' : 0x00000002,
+    },
+
     'InitializationModeQualifier' : {
         'InitOnDeviceReprogramINTEL' : 0,
         'InitOnDeviceResetINTEL' : 1,
@@ -1357,6 +1423,41 @@ spv = {
         'AutoINTEL' : 0,
     },
 
+    'MatrixMultiplyAccumulateOperandsShift' : {
+        'MatrixASignedComponentsINTEL' : 0,
+        'MatrixBSignedComponentsINTEL' : 1,
+        'MatrixCBFloat16INTEL' : 2,
+        'MatrixResultBFloat16INTEL' : 3,
+        'MatrixAPackedInt8INTEL' : 4,
+        'MatrixBPackedInt8INTEL' : 5,
+        'MatrixAPackedInt4INTEL' : 6,
+        'MatrixBPackedInt4INTEL' : 7,
+        'MatrixATF32INTEL' : 8,
+        'MatrixBTF32INTEL' : 9,
+        'MatrixAPackedFloat16INTEL' : 10,
+        'MatrixBPackedFloat16INTEL' : 11,
+        'MatrixAPackedBFloat16INTEL' : 12,
+        'MatrixBPackedBFloat16INTEL' : 13,
+    },
+
+    'MatrixMultiplyAccumulateOperandsMask' : {
+        'MaskNone' : 0,
+        'MatrixASignedComponentsINTEL' : 0x00000001,
+        'MatrixBSignedComponentsINTEL' : 0x00000002,
+        'MatrixCBFloat16INTEL' : 0x00000004,
+        'MatrixResultBFloat16INTEL' : 0x00000008,
+        'MatrixAPackedInt8INTEL' : 0x00000010,
+        'MatrixBPackedInt8INTEL' : 0x00000020,
+        'MatrixAPackedInt4INTEL' : 0x00000040,
+        'MatrixBPackedInt4INTEL' : 0x00000080,
+        'MatrixATF32INTEL' : 0x00000100,
+        'MatrixBTF32INTEL' : 0x00000200,
+        'MatrixAPackedFloat16INTEL' : 0x00000400,
+        'MatrixBPackedFloat16INTEL' : 0x00000800,
+        'MatrixAPackedBFloat16INTEL' : 0x00001000,
+        'MatrixBPackedBFloat16INTEL' : 0x00002000,
+    },
+
     'RawAccessChainOperandsShift' : {
         'RobustnessPerComponentNV' : 0,
         'RobustnessPerElementNV' : 1,
@@ -1371,6 +1472,31 @@ spv = {
     'FPEncoding' : {
     },
 
+    'CooperativeVectorMatrixLayout' : {
+        'RowMajorNV' : 0,
+        'ColumnMajorNV' : 1,
+        'InferencingOptimalNV' : 2,
+        'TrainingOptimalNV' : 3,
+    },
+
+    'ComponentType' : {
+        'Float16NV' : 0,
+        'Float32NV' : 1,
+        'Float64NV' : 2,
+        'SignedInt8NV' : 3,
+        'SignedInt16NV' : 4,
+        'SignedInt32NV' : 5,
+        'SignedInt64NV' : 6,
+        'UnsignedInt8NV' : 7,
+        'UnsignedInt16NV' : 8,
+        'UnsignedInt32NV' : 9,
+        'UnsignedInt64NV' : 10,
+        'SignedInt8PackedNV' : 1000491000,
+        'UnsignedInt8PackedNV' : 1000491001,
+        'FloatE4M3NV' : 1000491002,
+        'FloatE5M2NV' : 1000491003,
+    },
+
     'Op' : {
         'OpNop' : 0,
         'OpUndef' : 1,
@@ -1787,9 +1913,14 @@ spv = {
         'OpFragmentMaskFetchAMD' : 5011,
         'OpFragmentFetchAMD' : 5012,
         'OpReadClockKHR' : 5056,
-        'OpFinalizeNodePayloadsAMDX' : 5075,
+        'OpAllocateNodePayloadsAMDX' : 5074,
+        'OpEnqueueNodePayloadsAMDX' : 5075,
+        'OpTypeNodePayloadArrayAMDX' : 5076,
         'OpFinishWritingNodePayloadAMDX' : 5078,
-        'OpInitializeNodePayloadsAMDX' : 5090,
+        'OpNodePayloadArrayLengthAMDX' : 5090,
+        'OpIsNodePayloadValidAMDX' : 5101,
+        'OpConstantStringAMDX' : 5103,
+        'OpSpecConstantStringAMDX' : 5104,
         'OpGroupNonUniformQuadAllKHR' : 5110,
         'OpGroupNonUniformQuadAnyKHR' : 5111,
         'OpHitObjectRecordHitMotionNV' : 5249,
@@ -1826,12 +1957,20 @@ spv = {
         'OpReorderThreadWithHintNV' : 5280,
         'OpTypeHitObjectNV' : 5281,
         'OpImageSampleFootprintNV' : 5283,
+        'OpTypeCooperativeVectorNV' : 5288,
+        'OpCooperativeVectorMatrixMulNV' : 5289,
+        'OpCooperativeVectorOuterProductAccumulateNV' : 5290,
+        'OpCooperativeVectorReduceSumAccumulateNV' : 5291,
+        'OpCooperativeVectorMatrixMulAddNV' : 5292,
+        'OpCooperativeMatrixConvertNV' : 5293,
         'OpEmitMeshTasksEXT' : 5294,
         'OpSetMeshOutputsEXT' : 5295,
         'OpGroupNonUniformPartitionNV' : 5296,
         'OpWritePackedPrimitiveIndices4x8NV' : 5299,
         'OpFetchMicroTriangleVertexPositionNV' : 5300,
         'OpFetchMicroTriangleVertexBarycentricNV' : 5301,
+        'OpCooperativeVectorLoadNV' : 5302,
+        'OpCooperativeVectorStoreNV' : 5303,
         'OpReportIntersectionKHR' : 5334,
         'OpReportIntersectionNV' : 5334,
         'OpIgnoreIntersectionNV' : 5335,
@@ -1843,6 +1982,8 @@ spv = {
         'OpTypeAccelerationStructureKHR' : 5341,
         'OpTypeAccelerationStructureNV' : 5341,
         'OpExecuteCallableNV' : 5344,
+        'OpRayQueryGetClusterIdNV' : 5345,
+        'OpHitObjectGetClusterIdNV' : 5346,
         'OpTypeCooperativeMatrixNV' : 5358,
         'OpCooperativeMatrixLoadNV' : 5359,
         'OpCooperativeMatrixStoreNV' : 5360,
@@ -1850,9 +1991,26 @@ spv = {
         'OpCooperativeMatrixLengthNV' : 5362,
         'OpBeginInvocationInterlockEXT' : 5364,
         'OpEndInvocationInterlockEXT' : 5365,
+        'OpCooperativeMatrixReduceNV' : 5366,
+        'OpCooperativeMatrixLoadTensorNV' : 5367,
+        'OpCooperativeMatrixStoreTensorNV' : 5368,
+        'OpCooperativeMatrixPerElementOpNV' : 5369,
+        'OpTypeTensorLayoutNV' : 5370,
+        'OpTypeTensorViewNV' : 5371,
+        'OpCreateTensorLayoutNV' : 5372,
+        'OpTensorLayoutSetDimensionNV' : 5373,
+        'OpTensorLayoutSetStrideNV' : 5374,
+        'OpTensorLayoutSliceNV' : 5375,
+        'OpTensorLayoutSetClampValueNV' : 5376,
+        'OpCreateTensorViewNV' : 5377,
+        'OpTensorViewSetDimensionNV' : 5378,
+        'OpTensorViewSetStrideNV' : 5379,
         'OpDemoteToHelperInvocation' : 5380,
         'OpDemoteToHelperInvocationEXT' : 5380,
         'OpIsHelperInvocationEXT' : 5381,
+        'OpTensorViewSetClipNV' : 5382,
+        'OpTensorLayoutSetBlockSizeNV' : 5384,
+        'OpCooperativeMatrixTransposeNV' : 5390,
         'OpConvertUToImageNV' : 5391,
         'OpConvertUToSamplerNV' : 5392,
         'OpConvertImageToUNV' : 5393,
@@ -1861,6 +2019,19 @@ spv = {
         'OpConvertSampledImageToUNV' : 5396,
         'OpSamplerImageAddressingModeNV' : 5397,
         'OpRawAccessChainNV' : 5398,
+        'OpRayQueryGetIntersectionSpherePositionNV' : 5427,
+        'OpRayQueryGetIntersectionSphereRadiusNV' : 5428,
+        'OpRayQueryGetIntersectionLSSPositionsNV' : 5429,
+        'OpRayQueryGetIntersectionLSSRadiiNV' : 5430,
+        'OpRayQueryGetIntersectionLSSHitValueNV' : 5431,
+        'OpHitObjectGetSpherePositionNV' : 5432,
+        'OpHitObjectGetSphereRadiusNV' : 5433,
+        'OpHitObjectGetLSSPositionsNV' : 5434,
+        'OpHitObjectGetLSSRadiiNV' : 5435,
+        'OpHitObjectIsSphereHitNV' : 5436,
+        'OpHitObjectIsLSSHitNV' : 5437,
+        'OpRayQueryIsSphereHitNV' : 5438,
+        'OpRayQueryIsLSSHitNV' : 5439,
         'OpSubgroupShuffleINTEL' : 5571,
         'OpSubgroupShuffleDownINTEL' : 5572,
         'OpSubgroupShuffleUpINTEL' : 5573,
@@ -2107,7 +2278,14 @@ spv = {
         'OpConvertBF16ToFINTEL' : 6117,
         'OpControlBarrierArriveINTEL' : 6142,
         'OpControlBarrierWaitINTEL' : 6143,
+        'OpArithmeticFenceEXT' : 6145,
         'OpSubgroupBlockPrefetchINTEL' : 6221,
+        'OpSubgroup2DBlockLoadINTEL' : 6231,
+        'OpSubgroup2DBlockLoadTransformINTEL' : 6232,
+        'OpSubgroup2DBlockLoadTransposeINTEL' : 6233,
+        'OpSubgroup2DBlockPrefetchINTEL' : 6234,
+        'OpSubgroup2DBlockStoreINTEL' : 6235,
+        'OpSubgroupMatrixMultiplyAccumulateINTEL' : 6237,
         'OpGroupIMulKHR' : 6401,
         'OpGroupFMulKHR' : 6402,
         'OpGroupBitwiseAndKHR' : 6403,

include/vulkan/spirv-headers/spv.d

@@ -73,6 +73,7 @@ enum SourceLanguage : uint
     WGSL = 10,
     Slang = 11,
     Zig = 12,
+    Rust = 13,
     Max = 0x7fffffff,
 }
 
@@ -177,6 +178,7 @@ enum ExecutionMode : uint
     EarlyAndLateFragmentTestsAMD = 5017,
     StencilRefReplacingEXT = 5027,
     CoalescingAMDX = 5069,
+    IsApiEntryAMDX = 5070,
     MaxNodeRecursionAMDX = 5071,
     StaticNumWorkgroupsAMDX = 5072,
     ShaderIndexAMDX = 5073,
@@ -189,6 +191,7 @@ enum ExecutionMode : uint
     StencilRefLessBackAMD = 5084,
     QuadDerivativesKHR = 5088,
     RequireFullQuadsKHR = 5089,
+    SharesInputWithAMDX = 5102,
     OutputLinesEXT = 5269,
     OutputLinesNV = 5269,
     OutputPrimitivesEXT = 5270,
@@ -243,7 +246,6 @@ enum StorageClass : uint
     StorageBuffer = 12,
     TileImageEXT = 4172,
     NodePayloadAMDX = 5068,
-    NodeOutputPayloadAMDX = 5076,
     CallableDataKHR = 5328,
     CallableDataNV = 5328,
     IncomingCallableDataKHR = 5329,
@@ -571,6 +573,10 @@ enum Decoration : uint
     NodeMaxPayloadsAMDX = 5020,
     TrackFinishWritingAMDX = 5078,
     PayloadNodeNameAMDX = 5091,
+    PayloadNodeBaseIndexAMDX = 5098,
+    PayloadNodeSparseArrayAMDX = 5099,
+    PayloadNodeArraySizeAMDX = 5100,
+    PayloadDispatchIndirectAMDX = 5105,
     OverrideCoverageNV = 5248,
     PassthroughNV = 5250,
     ViewportRelativeNV = 5252,
@@ -735,7 +741,7 @@ enum BuiltIn : uint
     BaryCoordSmoothSampleAMD = 4997,
     BaryCoordPullModelAMD = 4998,
     FragStencilRefEXT = 5014,
-    CoalescedInputCountAMDX = 5021,
+    RemainingRecursionLevelsAMDX = 5021,
     ShaderIndexAMDX = 5073,
     ViewportMaskNV = 5253,
     SecondaryPositionNV = 5257,
@@ -795,12 +801,19 @@ enum BuiltIn : uint
     IncomingRayFlagsKHR = 5351,
     IncomingRayFlagsNV = 5351,
     RayGeometryIndexKHR = 5352,
+    HitIsSphereNV = 5359,
+    HitIsLSSNV = 5360,
+    HitSpherePositionNV = 5361,
     WarpsPerSMNV = 5374,
     SMCountNV = 5375,
     WarpIDNV = 5376,
     SMIDNV = 5377,
+    HitLSSPositionsNV = 5396,
     HitKindFrontFacingMicroTriangleNV = 5405,
     HitKindBackFacingMicroTriangleNV = 5406,
+    HitSphereRadiusNV = 5420,
+    HitLSSRadiiNV = 5421,
+    ClusterIDNV = 5436,
     CullMaskKHR = 6021,
     Max = 0x7fffffff,
 }
@@ -873,6 +886,7 @@ enum FunctionControlShift : uint
     DontInline = 1,
     Pure = 2,
     Const = 3,
+    OptNoneEXT = 16,
     OptNoneINTEL = 16,
     Max = 0x7fffffff,
 }
@@ -884,6 +898,7 @@ enum FunctionControlMask : uint
     DontInline = 0x00000002,
     Pure = 0x00000004,
     Const = 0x00000008,
+    OptNoneEXT = 0x00010000,
     OptNoneINTEL = 0x00010000,
 }
 
@@ -1196,9 +1211,20 @@ enum Capability : uint
     ShaderInvocationReorderNV = 5383,
     BindlessTextureNV = 5390,
     RayQueryPositionFetchKHR = 5391,
+    CooperativeVectorNV = 5394,
     AtomicFloat16VectorNV = 5404,
     RayTracingDisplacementMicromapNV = 5409,
     RawAccessChainsNV = 5414,
+    RayTracingSpheresGeometryNV = 5418,
+    RayTracingLinearSweptSpheresGeometryNV = 5419,
+    CooperativeMatrixReductionsNV = 5430,
+    CooperativeMatrixConversionsNV = 5431,
+    CooperativeMatrixPerElementOperationsNV = 5432,
+    CooperativeMatrixTensorAddressingNV = 5433,
+    CooperativeMatrixBlockLoadsNV = 5434,
+    CooperativeVectorTrainingNV = 5435,
+    RayTracingClusterAccelerationStructureNV = 5437,
+    TensorAddressingNV = 5439,
     SubgroupShuffleINTEL = 5568,
     SubgroupBufferBlockIOINTEL = 5569,
     SubgroupImageBlockIOINTEL = 5570,
@@ -1258,11 +1284,13 @@ enum Capability : uint
     AtomicFloat32AddEXT = 6033,
     AtomicFloat64AddEXT = 6034,
     LongCompositesINTEL = 6089,
+    OptNoneEXT = 6094,
     OptNoneINTEL = 6094,
     AtomicFloat16AddEXT = 6095,
     DebugInfoModuleINTEL = 6114,
     BFloat16ConversionINTEL = 6115,
     SplitBarrierINTEL = 6141,
+    ArithmeticFenceEXT = 6144,
     FPGAClusterAttributesV2INTEL = 6150,
     FPGAKernelAttributesv2INTEL = 6161,
     FPMaxErrorINTEL = 6169,
@@ -1271,6 +1299,10 @@ enum Capability : uint
     GlobalVariableHostAccessINTEL = 6187,
     GlobalVariableFPGADecorationsINTEL = 6189,
     SubgroupBufferPrefetchINTEL = 6220,
+    Subgroup2DBlockIOINTEL = 6228,
+    Subgroup2DBlockTransformINTEL = 6229,
+    Subgroup2DBlockTransposeINTEL = 6230,
+    SubgroupMatrixMultiplyAccumulateINTEL = 6236,
     GroupUniformArithmeticKHR = 6400,
     MaskedGatherScatterINTEL = 6427,
     CacheControlsINTEL = 6441,
@@ -1288,6 +1320,7 @@ enum RayFlagsShift : uint
     CullFrontFacingTrianglesKHR = 5,
     CullOpaqueKHR = 6,
     CullNoOpaqueKHR = 7,
+    SkipBuiltinPrimitivesNV = 8,
     SkipTrianglesKHR = 8,
     SkipAABBsKHR = 9,
     ForceOpacityMicromap2StateEXT = 10,
@@ -1305,6 +1338,7 @@ enum RayFlagsMask : uint
     CullFrontFacingTrianglesKHR = 0x00000020,
     CullOpaqueKHR = 0x00000040,
     CullNoOpaqueKHR = 0x00000080,
+    SkipBuiltinPrimitivesNV = 0x00000100,
     SkipTrianglesKHR = 0x00000100,
     SkipAABBsKHR = 0x00000200,
     ForceOpacityMicromap2StateEXT = 0x00000400,
@@ -1430,6 +1464,46 @@ enum CooperativeMatrixUse : uint
     Max = 0x7fffffff,
 }
 
+enum CooperativeMatrixReduceShift : uint
+{
+    Row = 0,
+    Column = 1,
+    _2x2 = 2,
+    Max = 0x7fffffff,
+}
+
+enum CooperativeMatrixReduceMask : uint
+{
+    MaskNone = 0,
+    Row = 0x00000001,
+    Column = 0x00000002,
+    _2x2 = 0x00000004,
+}
+
+enum TensorClampMode : uint
+{
+    Undefined = 0,
+    Constant = 1,
+    ClampToEdge = 2,
+    Repeat = 3,
+    RepeatMirrored = 4,
+    Max = 0x7fffffff,
+}
+
+enum TensorAddressingOperandsShift : uint
+{
+    TensorView = 0,
+    DecodeFunc = 1,
+    Max = 0x7fffffff,
+}
+
+enum TensorAddressingOperandsMask : uint
+{
+    MaskNone = 0,
+    TensorView = 0x00000001,
+    DecodeFunc = 0x00000002,
+}
+
 enum InitializationModeQualifier : uint
 {
     InitOnDeviceReprogramINTEL = 0,
@@ -1471,6 +1545,44 @@ enum NamedMaximumNumberOfRegisters : uint
     Max = 0x7fffffff,
 }
 
+enum MatrixMultiplyAccumulateOperandsShift : uint
+{
+    MatrixASignedComponentsINTEL = 0,
+    MatrixBSignedComponentsINTEL = 1,
+    MatrixCBFloat16INTEL = 2,
+    MatrixResultBFloat16INTEL = 3,
+    MatrixAPackedInt8INTEL = 4,
+    MatrixBPackedInt8INTEL = 5,
+    MatrixAPackedInt4INTEL = 6,
+    MatrixBPackedInt4INTEL = 7,
+    MatrixATF32INTEL = 8,
+    MatrixBTF32INTEL = 9,
+    MatrixAPackedFloat16INTEL = 10,
+    MatrixBPackedFloat16INTEL = 11,
+    MatrixAPackedBFloat16INTEL = 12,
+    MatrixBPackedBFloat16INTEL = 13,
+    Max = 0x7fffffff,
+}
+
+enum MatrixMultiplyAccumulateOperandsMask : uint
+{
+    MaskNone = 0,
+    MatrixASignedComponentsINTEL = 0x00000001,
+    MatrixBSignedComponentsINTEL = 0x00000002,
+    MatrixCBFloat16INTEL = 0x00000004,
+    MatrixResultBFloat16INTEL = 0x00000008,
+    MatrixAPackedInt8INTEL = 0x00000010,
+    MatrixBPackedInt8INTEL = 0x00000020,
+    MatrixAPackedInt4INTEL = 0x00000040,
+    MatrixBPackedInt4INTEL = 0x00000080,
+    MatrixATF32INTEL = 0x00000100,
+    MatrixBTF32INTEL = 0x00000200,
+    MatrixAPackedFloat16INTEL = 0x00000400,
+    MatrixBPackedFloat16INTEL = 0x00000800,
+    MatrixAPackedBFloat16INTEL = 0x00001000,
+    MatrixBPackedBFloat16INTEL = 0x00002000,
+}
+
 enum RawAccessChainOperandsShift : uint
 {
     RobustnessPerComponentNV = 0,
@@ -1490,6 +1602,35 @@ enum FPEncoding : uint
     Max = 0x7fffffff,
 }
 
+enum CooperativeVectorMatrixLayout : uint
+{
+    RowMajorNV = 0,
+    ColumnMajorNV = 1,
+    InferencingOptimalNV = 2,
+    TrainingOptimalNV = 3,
+    Max = 0x7fffffff,
+}
+
+enum ComponentType : uint
+{
+    Float16NV = 0,
+    Float32NV = 1,
+    Float64NV = 2,
+    SignedInt8NV = 3,
+    SignedInt16NV = 4,
+    SignedInt32NV = 5,
+    SignedInt64NV = 6,
+    UnsignedInt8NV = 7,
+    UnsignedInt16NV = 8,
+    UnsignedInt32NV = 9,
+    UnsignedInt64NV = 10,
+    SignedInt8PackedNV = 1000491000,
+    UnsignedInt8PackedNV = 1000491001,
+    FloatE4M3NV = 1000491002,
+    FloatE5M2NV = 1000491003,
+    Max = 0x7fffffff,
+}
+
 enum Op : uint
 {
     OpNop = 0,
@@ -1907,9 +2048,14 @@ enum Op : uint
     OpFragmentMaskFetchAMD = 5011,
     OpFragmentFetchAMD = 5012,
     OpReadClockKHR = 5056,
-    OpFinalizeNodePayloadsAMDX = 5075,
+    OpAllocateNodePayloadsAMDX = 5074,
+    OpEnqueueNodePayloadsAMDX = 5075,
+    OpTypeNodePayloadArrayAMDX = 5076,
     OpFinishWritingNodePayloadAMDX = 5078,
-    OpInitializeNodePayloadsAMDX = 5090,
+    OpNodePayloadArrayLengthAMDX = 5090,
+    OpIsNodePayloadValidAMDX = 5101,
+    OpConstantStringAMDX = 5103,
+    OpSpecConstantStringAMDX = 5104,
     OpGroupNonUniformQuadAllKHR = 5110,
     OpGroupNonUniformQuadAnyKHR = 5111,
     OpHitObjectRecordHitMotionNV = 5249,
@@ -1946,12 +2092,20 @@ enum Op : uint
     OpReorderThreadWithHintNV = 5280,
     OpTypeHitObjectNV = 5281,
     OpImageSampleFootprintNV = 5283,
+    OpTypeCooperativeVectorNV = 5288,
+    OpCooperativeVectorMatrixMulNV = 5289,
+    OpCooperativeVectorOuterProductAccumulateNV = 5290,
+    OpCooperativeVectorReduceSumAccumulateNV = 5291,
+    OpCooperativeVectorMatrixMulAddNV = 5292,
+    OpCooperativeMatrixConvertNV = 5293,
     OpEmitMeshTasksEXT = 5294,
     OpSetMeshOutputsEXT = 5295,
     OpGroupNonUniformPartitionNV = 5296,
     OpWritePackedPrimitiveIndices4x8NV = 5299,
     OpFetchMicroTriangleVertexPositionNV = 5300,
     OpFetchMicroTriangleVertexBarycentricNV = 5301,
+    OpCooperativeVectorLoadNV = 5302,
+    OpCooperativeVectorStoreNV = 5303,
     OpReportIntersectionKHR = 5334,
     OpReportIntersectionNV = 5334,
     OpIgnoreIntersectionNV = 5335,
@@ -1963,6 +2117,8 @@ enum Op : uint
     OpTypeAccelerationStructureKHR = 5341,
     OpTypeAccelerationStructureNV = 5341,
     OpExecuteCallableNV = 5344,
+    OpRayQueryGetClusterIdNV = 5345,
+    OpHitObjectGetClusterIdNV = 5346,
     OpTypeCooperativeMatrixNV = 5358,
     OpCooperativeMatrixLoadNV = 5359,
     OpCooperativeMatrixStoreNV = 5360,
@@ -1970,9 +2126,26 @@ enum Op : uint
     OpCooperativeMatrixLengthNV = 5362,
     OpBeginInvocationInterlockEXT = 5364,
     OpEndInvocationInterlockEXT = 5365,
+    OpCooperativeMatrixReduceNV = 5366,
+    OpCooperativeMatrixLoadTensorNV = 5367,
+    OpCooperativeMatrixStoreTensorNV = 5368,
+    OpCooperativeMatrixPerElementOpNV = 5369,
+    OpTypeTensorLayoutNV = 5370,
+    OpTypeTensorViewNV = 5371,
+    OpCreateTensorLayoutNV = 5372,
+    OpTensorLayoutSetDimensionNV = 5373,
+    OpTensorLayoutSetStrideNV = 5374,
+    OpTensorLayoutSliceNV = 5375,
+    OpTensorLayoutSetClampValueNV = 5376,
+    OpCreateTensorViewNV = 5377,
+    OpTensorViewSetDimensionNV = 5378,
+    OpTensorViewSetStrideNV = 5379,
     OpDemoteToHelperInvocation = 5380,
     OpDemoteToHelperInvocationEXT = 5380,
     OpIsHelperInvocationEXT = 5381,
+    OpTensorViewSetClipNV = 5382,
+    OpTensorLayoutSetBlockSizeNV = 5384,
+    OpCooperativeMatrixTransposeNV = 5390,
     OpConvertUToImageNV = 5391,
     OpConvertUToSamplerNV = 5392,
     OpConvertImageToUNV = 5393,
@@ -1981,6 +2154,19 @@ enum Op : uint
     OpConvertSampledImageToUNV = 5396,
     OpSamplerImageAddressingModeNV = 5397,
     OpRawAccessChainNV = 5398,
+    OpRayQueryGetIntersectionSpherePositionNV = 5427,
+    OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+    OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+    OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+    OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+    OpHitObjectGetSpherePositionNV = 5432,
+    OpHitObjectGetSphereRadiusNV = 5433,
+    OpHitObjectGetLSSPositionsNV = 5434,
+    OpHitObjectGetLSSRadiiNV = 5435,
+    OpHitObjectIsSphereHitNV = 5436,
+    OpHitObjectIsLSSHitNV = 5437,
+    OpRayQueryIsSphereHitNV = 5438,
+    OpRayQueryIsLSSHitNV = 5439,
     OpSubgroupShuffleINTEL = 5571,
     OpSubgroupShuffleDownINTEL = 5572,
     OpSubgroupShuffleUpINTEL = 5573,
@@ -2227,7 +2413,14 @@ enum Op : uint
     OpConvertBF16ToFINTEL = 6117,
     OpControlBarrierArriveINTEL = 6142,
     OpControlBarrierWaitINTEL = 6143,
+    OpArithmeticFenceEXT = 6145,
     OpSubgroupBlockPrefetchINTEL = 6221,
+    OpSubgroup2DBlockLoadINTEL = 6231,
+    OpSubgroup2DBlockLoadTransformINTEL = 6232,
+    OpSubgroup2DBlockLoadTransposeINTEL = 6233,
+    OpSubgroup2DBlockPrefetchINTEL = 6234,
+    OpSubgroup2DBlockStoreINTEL = 6235,
+    OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
     OpGroupIMulKHR = 6401,
     OpGroupFMulKHR = 6402,
     OpGroupBitwiseAndKHR = 6403,

include/vulkan/spirv-tools/instrument.hpp

@@ -1,79 +0,0 @@
-// Copyright (c) 2018 The Khronos Group Inc.
-// Copyright (c) 2018 Valve Corporation
-// Copyright (c) 2018 LunarG Inc.
-//
-// 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.
-
-#ifndef INCLUDE_SPIRV_TOOLS_INSTRUMENT_HPP_
-#define INCLUDE_SPIRV_TOOLS_INSTRUMENT_HPP_
-
-// Shader Instrumentation Interface
-//
-// This file provides an external interface for applications that wish to
-// communicate with shaders instrumented by passes created by:
-//
-//   CreateInstDebugPrintfPass
-//
-// More detailed documentation of these routines can be found in optimizer.hpp
-
-namespace spvtools {
-
-// Stream Output Buffer Offsets
-//
-// The following values provide offsets into the output buffer struct
-// generated by InstrumentPass::GenDebugStreamWrite. This method is utilized
-// by InstDebugPrintfPass.
-//
-// The 1st member of the debug output buffer contains a set of flags
-// controlling the behavior of instrumentation code.
-static const int kDebugOutputFlagsOffset = 0;
-
-// The 2nd member of the debug output buffer contains the next available word
-// in the data stream to be written. Shaders will atomically read and update
-// this value so as not to overwrite each others records. This value must be
-// initialized to zero
-static const int kDebugOutputSizeOffset = 1;
-
-// The 3rd member of the output buffer is the start of the stream of records
-// written by the instrumented shaders. Each record represents a validation
-// error. The format of the records is documented below.
-static const int kDebugOutputDataOffset = 2;
-
-// Common Stream Record Offsets
-//
-// The following are offsets to fields which are common to all records written
-// to the output stream.
-//
-// Each record first contains the size of the record in 32-bit words, including
-// the size word.
-static const int kInstCommonOutSize = 0;
-
-// This is the shader id passed by the layer when the instrumentation pass is
-// created.
-static const int kInstCommonOutShaderId = 1;
-
-// This is the ordinal position of the instruction within the SPIR-V shader
-// which generated the validation error.
-static const int kInstCommonOutInstructionIdx = 2;
-
-// Debug Buffer Bindings
-//
-// These are the bindings for the different buffers which are
-// read or written by the instrumentation passes.
-//
-// This is the output buffer written by InstDebugPrintfPass.
-static const int kDebugOutputPrintfStream = 3;
-
-}  // namespace spvtools
-
-#endif  // INCLUDE_SPIRV_TOOLS_INSTRUMENT_HPP_

include/vulkan/spirv-tools/libspirv.h

@@ -314,6 +314,18 @@ typedef enum spv_operand_type_t {
   SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS,
   // Optional enum type from SPV_NV_raw_access_chains
   SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS,
+  // Enum type from SPV_NV_tensor_addressing
+  SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE,
+  // Enum type from SPV_NV_cooperative_matrix2
+  SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE,
+  // Enum type from SPV_NV_cooperative_matrix2
+  SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS,
+  // Optional types from SPV_INTEL_subgroup_matrix_multiply_accumulate
+  SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS,
+  SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS,
+
+  SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT,
+  SPV_OPERAND_TYPE_COMPONENT_TYPE,
 
   // This is a sentinel value, and does not represent an operand type.
   // It should come last.
@@ -534,6 +546,7 @@ SPIRV_TOOLS_EXPORT const char* spvSoftwareVersionDetailsString(void);
 //    SPV_ENV_VULKAN_1_1_SPIRV_1_4 ->  SPIR-V 1.4
 //    SPV_ENV_VULKAN_1_2           ->  SPIR-V 1.5
 //    SPV_ENV_VULKAN_1_3           ->  SPIR-V 1.6
+//    SPV_ENV_VULKAN_1_4           ->  SPIR-V 1.6
 // Consult the description of API entry points for specific rules.
 typedef enum {
   SPV_ENV_UNIVERSAL_1_0,  // SPIR-V 1.0 latest revision, no other restrictions.
@@ -571,6 +584,7 @@ typedef enum {
 
   SPV_ENV_UNIVERSAL_1_6,  // SPIR-V 1.6 latest revision, no other restrictions.
   SPV_ENV_VULKAN_1_3,     // Vulkan 1.3 latest revision.
+  SPV_ENV_VULKAN_1_4,     // Vulkan 1.4 latest revision.
 
   SPV_ENV_MAX  // Keep this as the last enum value.
 } spv_target_env;
@@ -721,6 +735,15 @@ SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetSkipBlockLayout(
 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowLocalSizeId(
     spv_validator_options options, bool val);
 
+// Allow Offset (in addition to ConstOffset) for texture operations.
+// Was added for VK_KHR_maintenance8
+SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowOffsetTextureOperand(
+    spv_validator_options options, bool val);
+
+// Allow base operands of some bit operations to be non-32-bit wide.
+SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowVulkan32BitBitwise(
+    spv_validator_options options, bool val);
+
 // Whether friendly names should be used in validation error messages.
 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetFriendlyNames(
     spv_validator_options options, bool val);

include/vulkan/spirv-tools/libspirv.hpp

@@ -126,6 +126,17 @@ class SPIRV_TOOLS_EXPORT ValidatorOptions {
     spvValidatorOptionsSetAllowLocalSizeId(options_, val);
   }
 
+  // Allow Offset (in addition to ConstOffset) for texture
+  // operations. Was added for VK_KHR_maintenance8
+  void SetAllowOffsetTextureOperand(bool val) {
+    spvValidatorOptionsSetAllowOffsetTextureOperand(options_, val);
+  }
+
+  // Allow base operands of some bit operations to be non-32-bit wide.
+  void SetAllowVulkan32BitBitwise(bool val) {
+    spvValidatorOptionsSetAllowVulkan32BitBitwise(options_, val);
+  }
+
   // Records whether or not the validator should relax the rules on pointer
   // usage in logical addressing mode.
   //

include/vulkan/spirv-tools/optimizer.hpp

@@ -747,18 +747,6 @@ Optimizer::PassToken CreateReduceLoadSizePass(
 // them into a single instruction where possible.
 Optimizer::PassToken CreateCombineAccessChainsPass();
 
-// Create a pass to instrument OpDebugPrintf instructions.
-// This pass replaces all OpDebugPrintf instructions with instructions to write
-// a record containing the string id and the all specified values into a special
-// printf output buffer (if space allows). This pass is designed to support
-// the printf validation in the Vulkan validation layers.
-//
-// The instrumentation will write buffers in debug descriptor set |desc_set|.
-// It will write |shader_id| in each output record to identify the shader
-// module which generated the record.
-Optimizer::PassToken CreateInstDebugPrintfPass(uint32_t desc_set,
-                                               uint32_t shader_id);
-
 // Create a pass to upgrade to the VulkanKHR memory model.
 // This pass upgrades the Logical GLSL450 memory model to Logical VulkanKHR.
 // Additionally, it modifies memory, image, atomic and barrier operations to

include/vulkan/spirv_cross/spirv_common.hpp

@@ -578,7 +578,9 @@ struct SPIRType : IVariant
 		// Keep internal types at the end.
 		ControlPointArray,
 		Interpolant,
-		Char
+		Char,
+		// MSL specific type, that is used by 'object'(analog of 'task' from glsl) shader.
+		MeshGridProperties
 	};
 
 	// Scalar/vector/matrix support.
@@ -746,6 +748,10 @@ struct SPIRExpression : IVariant
 	// A list of expressions which this expression depends on.
 	SmallVector<ID> expression_dependencies;
 
+	// Similar as expression dependencies, but does not stop the tracking for force-temporary variables.
+	// We need to know the full chain from store back to any SSA variable.
+	SmallVector<ID> invariance_dependencies;
+
 	// By reading this expression, we implicitly read these expressions as well.
 	// Used by access chain Store and Load since we read multiple expressions in this case.
 	SmallVector<ID> implied_read_expressions;
@@ -1404,6 +1410,10 @@ struct SPIRConstant : IVariant
 	// If true, this is a LUT, and should always be declared in the outer scope.
 	bool is_used_as_lut = false;
 
+	// If this is a null constant of array type with specialized length.
+	// May require special handling in initializer
+	bool is_null_array_specialized_length = false;
+
 	// For composites which are constant arrays, etc.
 	SmallVector<ConstantID> subconstants;
 
@@ -1598,6 +1608,8 @@ struct AccessChainMeta
 	bool flattened_struct = false;
 	bool relaxed_precision = false;
 	bool access_meshlet_position_y = false;
+	bool chain_is_builtin = false;
+	spv::BuiltIn builtin = {};
 };
 
 enum ExtendedDecorations

include/vulkan/spirv_cross/spirv_cross_c.h

@@ -40,7 +40,7 @@ extern "C" {
 /* Bumped if ABI or API breaks backwards compatibility. */
 #define SPVC_C_API_VERSION_MAJOR 0
 /* Bumped if APIs or enumerations are added in a backwards compatible way. */
-#define SPVC_C_API_VERSION_MINOR 64
+#define SPVC_C_API_VERSION_MINOR 65
 /* Bumped if internal implementation details change. */
 #define SPVC_C_API_VERSION_PATCH 0
 
@@ -748,6 +748,8 @@ typedef enum spvc_compiler_option
 	SPVC_COMPILER_OPTION_HLSL_USE_ENTRY_POINT_NAME = 90 | SPVC_COMPILER_OPTION_HLSL_BIT,
 	SPVC_COMPILER_OPTION_HLSL_PRESERVE_STRUCTURED_BUFFERS = 91 | SPVC_COMPILER_OPTION_HLSL_BIT,
 
+	SPVC_COMPILER_OPTION_MSL_AUTO_DISABLE_RASTERIZATION = 92 | SPVC_COMPILER_OPTION_MSL_BIT,
+
 	SPVC_COMPILER_OPTION_INT_MAX = 0x7fffffff
 } spvc_compiler_option;
 

include/vulkan/spirv_cross/spirv_glsl.hpp

@@ -297,6 +297,9 @@ public:
 		float_formatter = formatter;
 	}
 
+	// Returns the macro name corresponding to constant id
+	std::string constant_value_macro_name(uint32_t id) const;
+
 protected:
 	struct ShaderSubgroupSupportHelper
 	{
@@ -450,6 +453,7 @@ protected:
 	virtual std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0);
 	virtual bool variable_decl_is_remapped_storage(const SPIRVariable &var, spv::StorageClass storage) const;
 	virtual std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id);
+	virtual void emit_workgroup_initialization(const SPIRVariable &var);
 
 	struct TextureFunctionBaseArguments
 	{
@@ -622,6 +626,7 @@ protected:
 		const char *uint16_t_literal_suffix = "us";
 		const char *nonuniform_qualifier = "nonuniformEXT";
 		const char *boolean_mix_function = "mix";
+		std::string constant_null_initializer = "";
 		SPIRType::BaseType boolean_in_struct_remapped_type = SPIRType::Boolean;
 		bool swizzle_is_function = false;
 		bool shared_is_implied = false;
@@ -629,6 +634,7 @@ protected:
 		bool explicit_struct_type = false;
 		bool use_initializer_list = false;
 		bool use_typed_initializer_list = false;
+		bool requires_matching_array_initializer = false;
 		bool can_declare_struct_inline = true;
 		bool can_declare_arrays_inline = true;
 		bool native_row_major_matrix = true;
@@ -679,7 +685,6 @@ protected:
 	                                    const SmallVector<uint32_t> &indices);
 	void emit_block_chain(SPIRBlock &block);
 	void emit_hoisted_temporaries(SmallVector<std::pair<TypeID, ID>> &temporaries);
-	std::string constant_value_macro_name(uint32_t id);
 	int get_constant_mapping_to_workgroup_component(const SPIRConstant &constant) const;
 	void emit_constant(const SPIRConstant &constant);
 	void emit_specialization_constant_op(const SPIRConstantOp &constant);
@@ -695,6 +700,7 @@ protected:
 	void emit_variable_temporary_copies(const SPIRVariable &var);
 
 	bool should_dereference(uint32_t id);
+	bool should_dereference_caller_param(uint32_t id);
 	bool should_forward(uint32_t id) const;
 	bool should_suppress_usage_tracking(uint32_t id) const;
 	void emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp);
@@ -794,6 +800,7 @@ protected:
 	SPIRExpression &emit_uninitialized_temporary_expression(uint32_t type, uint32_t id);
 	void append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector<std::string> &arglist);
 	std::string to_non_uniform_aware_expression(uint32_t id);
+	std::string to_atomic_ptr_expression(uint32_t id);
 	std::string to_expression(uint32_t id, bool register_expression_read = true);
 	std::string to_composite_constructor_expression(const SPIRType &parent_type, uint32_t id, bool block_like_type);
 	std::string to_rerolled_array_expression(const SPIRType &parent_type, const std::string &expr, const SPIRType &type);

include/vulkan/spirv_cross/spirv_hlsl.hpp

@@ -408,6 +408,8 @@ private:
 	std::vector<TypeID> composite_selection_workaround_types;
 
 	std::string get_inner_entry_point_name() const;
+
+	void cast_to_variable_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type) override;
 };
 } // namespace SPIRV_CROSS_NAMESPACE
 

include/vulkan/spirv_cross/spirv_msl.hpp

@@ -536,6 +536,10 @@ public:
 		// if the fragment does not modify the depth value.
 		bool input_attachment_is_ds_attachment = false;
 
+		// If BuiltInPosition is not written, automatically disable rasterization.
+		// The result can be queried with get_is_rasterization_disabled.
+		bool auto_disable_rasterization = false;
+
 		bool is_ios() const
 		{
 			return platform == iOS;
@@ -756,6 +760,11 @@ public:
 	void set_combined_sampler_suffix(const char *suffix);
 	const char *get_combined_sampler_suffix() const;
 
+	// Information about specialization constants that are translated into MSL macros
+	// instead of using function constant
+	// These must only be called after a successful call to CompilerMSL::compile().
+	bool specialization_constant_is_macro(uint32_t constant_id) const;
+
 protected:
 	// An enum of SPIR-V functions that are implemented in additional
 	// source code that is added to the shader if necessary.
@@ -838,7 +847,9 @@ protected:
 		SPVFuncImplPaddedStd140,
 		SPVFuncImplReduceAdd,
 		SPVFuncImplImageFence,
-		SPVFuncImplTextureCast
+		SPVFuncImplTextureCast,
+		SPVFuncImplMulExtended,
+		SPVFuncImplSetMeshOutputsEXT,
 	};
 
 	// If the underlying resource has been used for comparison then duplicate loads of that resource must be too
@@ -867,6 +878,10 @@ protected:
 	std::string type_to_glsl(const SPIRType &type, uint32_t id, bool member);
 	std::string type_to_glsl(const SPIRType &type, uint32_t id = 0) override;
 	void emit_block_hints(const SPIRBlock &block) override;
+	void emit_mesh_entry_point();
+	void emit_mesh_outputs();
+	void emit_mesh_tasks(SPIRBlock &block) override;
+	void emit_workgroup_initialization(const SPIRVariable &var) override;
 
 	// Allow Metal to use the array<T> template to make arrays a value type
 	std::string type_to_array_glsl(const SPIRType &type, uint32_t variable_id) override;
@@ -918,6 +933,7 @@ protected:
 
 	bool is_tesc_shader() const;
 	bool is_tese_shader() const;
+	bool is_mesh_shader() const;
 
 	void preprocess_op_codes();
 	void localize_global_variables();
@@ -932,6 +948,7 @@ protected:
 	                                            std::unordered_set<uint32_t> &processed_func_ids);
 	uint32_t add_interface_block(spv::StorageClass storage, bool patch = false);
 	uint32_t add_interface_block_pointer(uint32_t ib_var_id, spv::StorageClass storage);
+	uint32_t add_meshlet_block(bool per_primitive);
 
 	struct InterfaceBlockMeta
 	{
@@ -1103,12 +1120,17 @@ protected:
 	uint32_t builtin_stage_input_size_id = 0;
 	uint32_t builtin_local_invocation_index_id = 0;
 	uint32_t builtin_workgroup_size_id = 0;
+	uint32_t builtin_mesh_primitive_indices_id = 0;
+	uint32_t builtin_mesh_sizes_id = 0;
+	uint32_t builtin_task_grid_id = 0;
 	uint32_t builtin_frag_depth_id = 0;
 	uint32_t swizzle_buffer_id = 0;
 	uint32_t buffer_size_buffer_id = 0;
 	uint32_t view_mask_buffer_id = 0;
 	uint32_t dynamic_offsets_buffer_id = 0;
 	uint32_t uint_type_id = 0;
+	uint32_t shared_uint_type_id = 0;
+	uint32_t meshlet_type_id = 0;
 	uint32_t argument_buffer_padding_buffer_type_id = 0;
 	uint32_t argument_buffer_padding_image_type_id = 0;
 	uint32_t argument_buffer_padding_sampler_type_id = 0;
@@ -1121,6 +1143,7 @@ protected:
 	void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression) override;
 
 	void analyze_sampled_image_usage();
+	void analyze_workgroup_variables();
 
 	bool access_chain_needs_stage_io_builtin_translation(uint32_t base) override;
 	bool prepare_access_chain_for_scalar_access(std::string &expr, const SPIRType &type, spv::StorageClass storage,
@@ -1155,6 +1178,7 @@ protected:
 	std::set<std::string> pragma_lines;
 	std::set<std::string> typedef_lines;
 	SmallVector<uint32_t> vars_needing_early_declaration;
+	std::unordered_set<uint32_t> constant_macro_ids;
 
 	std::unordered_map<StageSetBinding, std::pair<MSLResourceBinding, bool>, InternalHasher> resource_bindings;
 	std::unordered_map<StageSetBinding, uint32_t, InternalHasher> resource_arg_buff_idx_to_binding_number;
@@ -1173,6 +1197,8 @@ protected:
 	VariableID stage_out_ptr_var_id = 0;
 	VariableID tess_level_inner_var_id = 0;
 	VariableID tess_level_outer_var_id = 0;
+	VariableID mesh_out_per_vertex = 0;
+	VariableID mesh_out_per_primitive = 0;
 	VariableID stage_out_masked_builtin_type_id = 0;
 
 	// Handle HLSL-style 0-based vertex/instance index.
@@ -1200,6 +1226,7 @@ protected:
 	bool needs_subgroup_size = false;
 	bool needs_sample_id = false;
 	bool needs_helper_invocation = false;
+	bool needs_workgroup_zero_init = false;
 	bool writes_to_depth = false;
 	std::string qual_pos_var_name;
 	std::string stage_in_var_name = "in";
@@ -1262,6 +1289,7 @@ protected:
 
 	bool suppress_missing_prototypes = false;
 	bool suppress_incompatible_pointer_types_discard_qualifiers = false;
+	bool suppress_sometimes_unitialized = false;
 
 	void add_spv_func_and_recompile(SPVFuncImpl spv_func);
 

include/vulkan/vk_video/vulkan_video_codec_av1std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_AV1STD_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -132,7 +132,7 @@ typedef enum 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_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,
@@ -144,6 +144,8 @@ typedef enum StdVideoAV1ColorPrimaries {
     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_BT_UNSPECIFIED is a deprecated alias
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
     STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF
 } StdVideoAV1ColorPrimaries;
 

include/vulkan/vk_video/vulkan_video_codec_av1std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vk_video/vulkan_video_codec_av1std_encode.h

@@ -0,0 +1,143 @@
+#ifndef VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_
+#define VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ 1
+
+/*
+** Copyright 2015-2025 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_encode is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_av1std_encode 1
+#include "vulkan_video_codec_av1std.h"
+
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_encode"
+typedef struct StdVideoEncodeAV1DecoderModelInfo {
+    uint8_t     buffer_delay_length_minus_1;
+    uint8_t     buffer_removal_time_length_minus_1;
+    uint8_t     frame_presentation_time_length_minus_1;
+    uint8_t     reserved1;
+    uint32_t    num_units_in_decoding_tick;
+} StdVideoEncodeAV1DecoderModelInfo;
+
+typedef struct StdVideoEncodeAV1ExtensionHeader {
+    uint8_t    temporal_id;
+    uint8_t    spatial_id;
+} StdVideoEncodeAV1ExtensionHeader;
+
+typedef struct StdVideoEncodeAV1OperatingPointInfoFlags {
+    uint32_t    decoder_model_present_for_this_op : 1;
+    uint32_t    low_delay_mode_flag : 1;
+    uint32_t    initial_display_delay_present_for_this_op : 1;
+    uint32_t    reserved : 29;
+} StdVideoEncodeAV1OperatingPointInfoFlags;
+
+typedef struct StdVideoEncodeAV1OperatingPointInfo {
+    StdVideoEncodeAV1OperatingPointInfoFlags    flags;
+    uint16_t                                    operating_point_idc;
+    uint8_t                                     seq_level_idx;
+    uint8_t                                     seq_tier;
+    uint32_t                                    decoder_buffer_delay;
+    uint32_t                                    encoder_buffer_delay;
+    uint8_t                                     initial_display_delay_minus_1;
+} StdVideoEncodeAV1OperatingPointInfo;
+
+typedef struct StdVideoEncodeAV1PictureInfoFlags {
+    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    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    show_frame : 1;
+    uint32_t    showable_frame : 1;
+    uint32_t    reserved : 3;
+} StdVideoEncodeAV1PictureInfoFlags;
+
+typedef struct StdVideoEncodeAV1PictureInfo {
+    StdVideoEncodeAV1PictureInfoFlags          flags;
+    StdVideoAV1FrameType                       frame_type;
+    uint32_t                                   frame_presentation_time;
+    uint32_t                                   current_frame_id;
+    uint8_t                                    order_hint;
+    uint8_t                                    primary_ref_frame;
+    uint8_t                                    refresh_frame_flags;
+    uint8_t                                    coded_denom;
+    uint16_t                                   render_width_minus_1;
+    uint16_t                                   render_height_minus_1;
+    StdVideoAV1InterpolationFilter             interpolation_filter;
+    StdVideoAV1TxMode                          TxMode;
+    uint8_t                                    delta_q_res;
+    uint8_t                                    delta_lf_res;
+    uint8_t                                    ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    int8_t                                     ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME];
+    uint8_t                                    reserved1[3];
+    uint32_t                                   delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME];
+    const StdVideoAV1TileInfo*                 pTileInfo;
+    const StdVideoAV1Quantization*             pQuantization;
+    const StdVideoAV1Segmentation*             pSegmentation;
+    const StdVideoAV1LoopFilter*               pLoopFilter;
+    const StdVideoAV1CDEF*                     pCDEF;
+    const StdVideoAV1LoopRestoration*          pLoopRestoration;
+    const StdVideoAV1GlobalMotion*             pGlobalMotion;
+    const StdVideoEncodeAV1ExtensionHeader*    pExtensionHeader;
+    const uint32_t*                            pBufferRemovalTimes;
+} StdVideoEncodeAV1PictureInfo;
+
+typedef struct StdVideoEncodeAV1ReferenceInfoFlags {
+    uint32_t    disable_frame_end_update_cdf : 1;
+    uint32_t    segmentation_enabled : 1;
+    uint32_t    reserved : 30;
+} StdVideoEncodeAV1ReferenceInfoFlags;
+
+typedef struct StdVideoEncodeAV1ReferenceInfo {
+    StdVideoEncodeAV1ReferenceInfoFlags        flags;
+    uint32_t                                   RefFrameId;
+    StdVideoAV1FrameType                       frame_type;
+    uint8_t                                    OrderHint;
+    uint8_t                                    reserved1[3];
+    const StdVideoEncodeAV1ExtensionHeader*    pExtensionHeader;
+} StdVideoEncodeAV1ReferenceInfo;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/vulkan/vk_video/vulkan_video_codec_h264std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vk_video/vulkan_video_codec_h264std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vk_video/vulkan_video_codec_h264std_encode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vk_video/vulkan_video_codec_h265std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vk_video/vulkan_video_codec_h265std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vk_video/vulkan_video_codec_h265std_encode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vk_video/vulkan_video_codecs_common.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODECS_COMMON_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/utility/vk_concurrent_unordered_map.hpp

@@ -9,6 +9,8 @@
 
 #pragma once
 
+#include <stdint.h>
+
 #include <array>
 #include <functional>
 #include <mutex>

include/vulkan/vulkan/utility/vk_format_utils.h

@@ -1,8 +1,8 @@
 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See format_utils_generator.py for modifications
-// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
+// Copyright 2023-2025 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 
@@ -249,6 +249,8 @@ inline bool vkuFormatIsSinglePlane_422(VkFormat format);
 inline uint32_t vkuFormatPlaneCount(VkFormat format);
 
 // Returns whether a VkFormat is multiplane
+// Note - Formats like VK_FORMAT_G8B8G8R8_422_UNORM are NOT multi-planar, they require a
+//        VkSamplerYcbcrConversion and you should use vkuFormatRequiresYcbcrConversion instead
 inline bool vkuFormatIsMultiplane(VkFormat format) { return ((vkuFormatPlaneCount(format)) > 1u); }
 
 // Returns a VkFormat that is compatible with a given plane of a multiplane format
@@ -259,6 +261,10 @@ inline VkFormat vkuFindMultiplaneCompatibleFormat(VkFormat mp_fmt, VkImageAspect
 // Will return {1, 1} if given a plane aspect that doesn't exist for the VkFormat
 inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspectFlagBits plane_aspect);
 
+// From table in spec vkspec.html#formats-compatible-zs-color
+// Introduced in VK_KHR_maintenance8 to allow copying between color and depth/stencil formats
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask);
+
 // Returns the count of components in a VkFormat
 inline uint32_t vkuFormatComponentCount(VkFormat format);
 
@@ -268,15 +274,23 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
-// Return true if a VkFormat is 'normal', with one texel per format element
+// Returns the number of texels inside a texel block
-inline bool vkuFormatElementIsTexel(VkFormat format);
+// Will always be 1 when not using compressed block formats
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format);
+
+// Returns the number of bytes in a single Texel Block.
+// When dealing with a depth/stencil format, need to consider using vkuFormatStencilSize or vkuFormatDepthSize.
+// When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format);
 
 // Return size, in bytes, of one element of a VkFormat
 // Format must not be a depth, stencil, or multiplane format
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSize(VkFormat format);
 
 // Return the size in bytes of one texel of a VkFormat
 // For compressed or multi-plane, this may be a fractional number
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
 
 // Return the size in bytes of one texel of a VkFormat
@@ -349,8 +363,8 @@ struct VKU_FORMAT_COMPONENT_INFO {
 // Generic information for all formats
 struct VKU_FORMAT_INFO {
     enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
-    uint32_t block_size;  // bytes
+    uint32_t texel_block_size;  // bytes
-    uint32_t texel_per_block;
+    uint32_t texels_per_block;
     VkExtent3D block_extent;
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
@@ -381,10 +395,10 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
         case VK_FORMAT_A1R5G5B5_UNORM_PACK16: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}}};
             return out; }
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: {
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}}};
             return out; }
-        case VK_FORMAT_A8_UNORM_KHR: {
+        case VK_FORMAT_A8_UNORM: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
             return out; }
         case VK_FORMAT_R8_UNORM: {
@@ -1426,8 +1440,8 @@ bool vkuFormatIsUNORM(VkFormat format) {
         case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
         case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
         case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
-        case VK_FORMAT_A8_UNORM_KHR:
+        case VK_FORMAT_A8_UNORM:
         case VK_FORMAT_R8_UNORM:
         case VK_FORMAT_R8G8_UNORM:
         case VK_FORMAT_R8G8B8_UNORM:
@@ -1811,7 +1825,7 @@ bool vkuFormatIsPacked(VkFormat format) {
         case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
         case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
         case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
         case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
         case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
         case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
@@ -2031,24 +2045,49 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
     return divisors;
 }
 
+// TODO - This should be generated, but will need updating the spec XML and table
+// Some few case don't have an aspect mask, so might need to check both the Depth and Stencil possiblity
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask) {
+    bool valid = false;
+
+    if (aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) {
+        if (ds_format == VK_FORMAT_S8_UINT || ds_format == VK_FORMAT_D16_UNORM_S8_UINT ||
+            ds_format == VK_FORMAT_D24_UNORM_S8_UINT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
+                      color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM);
+        }
+    }
+
+    if (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) {
+        if (ds_format == VK_FORMAT_D32_SFLOAT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
+            ds_format == VK_FORMAT_X8_D24_UNORM_PACK32 || ds_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT);
+        }
+        if (ds_format == VK_FORMAT_D16_UNORM || ds_format == VK_FORMAT_D16_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
+                      color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT);
+        }
+    }
+
+    return valid;
+}
+
 inline uint32_t vkuFormatComponentCount(VkFormat format) { return vkuGetFormatInfo(format).component_count; }
 
 inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetFormatInfo(format).block_extent; }
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
-inline bool vkuFormatElementIsTexel(VkFormat format) {
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatInfo(format).texels_per_block; }
-    if (vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) || vkuFormatIsMultiplane(format)) {
-        return false;
-    } else {
-        return true;
-    }
-}
 
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
+
+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSize(VkFormat format) {
     return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
 }
 
+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
     // Depth/Stencil aspect have separate helper functions
     if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
@@ -2061,7 +2100,7 @@ inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFla
         format = vkuFindMultiplaneCompatibleFormat(format, aspectMask);
     }
 
-    return vkuGetFormatInfo(format).block_size;
+    return vkuGetFormatInfo(format).texel_block_size;
 }
 
 inline double vkuFormatTexelSize(VkFormat format) {
@@ -2080,7 +2119,7 @@ inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBit
 
 inline bool vkuFormatIs8bit(VkFormat format) {
     switch (format) {
-        case VK_FORMAT_A8_UNORM_KHR:
+        case VK_FORMAT_A8_UNORM:
         case VK_FORMAT_R8_UNORM:
         case VK_FORMAT_R8_SNORM:
         case VK_FORMAT_R8_USCALED:

include/vulkan/vulkan/vk_platform.h

@@ -2,7 +2,7 @@
 // File: vk_platform.h
 //
 /*
-** Copyright 2014-2024 The Khronos Group Inc.
+** Copyright 2014-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan.h

@@ -2,7 +2,7 @@
 #define VULKAN_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_android.h

@@ -2,7 +2,7 @@
 #define VULKAN_ANDROID_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_beta.h

@@ -2,7 +2,7 @@
 #define VULKAN_BETA_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -53,13 +53,14 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
 
 // 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
+#define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 2
 #define VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME "VK_AMDX_shader_enqueue"
 #define VK_SHADER_INDEX_UNUSED_AMDX       (~0U)
 typedef struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX {
     VkStructureType    sType;
     void*              pNext;
     VkBool32           shaderEnqueue;
+    VkBool32           shaderMeshEnqueue;
 } VkPhysicalDeviceShaderEnqueueFeaturesAMDX;
 
 typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
@@ -70,12 +71,16 @@ typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
     uint32_t           maxExecutionGraphShaderPayloadSize;
     uint32_t           maxExecutionGraphShaderPayloadCount;
     uint32_t           executionGraphDispatchAddressAlignment;
+    uint32_t           maxExecutionGraphWorkgroupCount[3];
+    uint32_t           maxExecutionGraphWorkgroups;
 } VkPhysicalDeviceShaderEnqueuePropertiesAMDX;
 
 typedef struct VkExecutionGraphPipelineScratchSizeAMDX {
     VkStructureType    sType;
     void*              pNext;
-    VkDeviceSize       size;
+    VkDeviceSize       minSize;
+    VkDeviceSize       maxSize;
+    VkDeviceSize       sizeGranularity;
 } VkExecutionGraphPipelineScratchSizeAMDX;
 
 typedef struct VkExecutionGraphPipelineCreateInfoAMDX {
@@ -118,10 +123,10 @@ typedef struct VkPipelineShaderStageNodeCreateInfoAMDX {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateExecutionGraphPipelinesAMDX)(VkDevice                                        device, VkPipelineCache                 pipelineCache, uint32_t                                        createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks*    pAllocator, VkPipeline*               pPipelines);
 typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)(VkDevice                                        device, VkPipeline                                      executionGraph, VkExecutionGraphPipelineScratchSizeAMDX*        pSizeInfo);
 typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineNodeIndexAMDX)(VkDevice                                        device, VkPipeline                                      executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX*  pNodeInfo, uint32_t*                                       pNodeIndex);
-typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch);
+typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer                                 commandBuffer, VkPipeline                                      executionGraph, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, const VkDispatchGraphCountInfoAMDX*              pCountInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, const VkDispatchGraphCountInfoAMDX*             pCountInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, const VkDispatchGraphCountInfoAMDX*              pCountInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, const VkDispatchGraphCountInfoAMDX*             pCountInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceAddress                                 countInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, VkDeviceAddress                                 countInfo);
 
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(
@@ -145,21 +150,26 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(
 
 VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(
     VkCommandBuffer                             commandBuffer,
-    VkDeviceAddress                             scratch);
+    VkPipeline                                  executionGraph,
+    VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(
     VkCommandBuffer                             commandBuffer,
     VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
     const VkDispatchGraphCountInfoAMDX*         pCountInfo);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(
     VkCommandBuffer                             commandBuffer,
     VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
     const VkDispatchGraphCountInfoAMDX*         pCountInfo);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(
     VkCommandBuffer                             commandBuffer,
     VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
     VkDeviceAddress                             countInfo);
 #endif
 

include/vulkan/vulkan/vulkan_directfb.h

@@ -2,7 +2,7 @@
 #define VULKAN_DIRECTFB_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_extension_inspection.hpp

@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -46,7 +46,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::map<std::string, std::string> const & getDeprecatedExtensions()
   {
-    static std::map<std::string, std::string> deprecatedExtensions = {
+    static const std::map<std::string, std::string> deprecatedExtensions = {
       { "VK_EXT_debug_report", "VK_EXT_debug_utils" },
       { "VK_NV_glsl_shader", "" },
       { "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" },
@@ -76,7 +76,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::set<std::string> const & getDeviceExtensions()
   {
-    static std::set<std::string> deviceExtensions = {
+    static const std::set<std::string> deviceExtensions = {
       "VK_KHR_swapchain",
       "VK_KHR_display_swapchain",
       "VK_NV_glsl_shader",
@@ -346,6 +346,7 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_EXT_depth_clip_control",
       "VK_EXT_primitive_topology_list_restart",
       "VK_KHR_format_feature_flags2",
+      "VK_EXT_present_mode_fifo_latest_ready",
 #if defined( VK_USE_PLATFORM_FUCHSIA )
       "VK_FUCHSIA_external_memory",
       "VK_FUCHSIA_external_semaphore",
@@ -387,6 +388,7 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_NV_copy_memory_indirect",
       "VK_NV_memory_decompression",
       "VK_NV_device_generated_commands_compute",
+      "VK_NV_ray_tracing_linear_swept_spheres",
       "VK_NV_linear_color_attachment",
       "VK_KHR_shader_maximal_reconvergence",
       "VK_EXT_image_compression_control_swapchain",
@@ -412,6 +414,7 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_SEC_amigo_profiling",
       "VK_QCOM_multiview_per_view_viewports",
       "VK_NV_ray_tracing_invocation_reorder",
+      "VK_NV_cooperative_vector",
       "VK_NV_extended_sparse_address_space",
       "VK_EXT_mutable_descriptor_type",
       "VK_EXT_legacy_vertex_attributes",
@@ -423,6 +426,7 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_QCOM_multiview_per_view_render_areas",
       "VK_KHR_compute_shader_derivatives",
       "VK_KHR_video_decode_av1",
+      "VK_KHR_video_encode_av1",
       "VK_KHR_video_maintenance1",
       "VK_NV_per_stage_descriptor_set",
       "VK_QCOM_image_processing2",
@@ -443,6 +447,7 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_KHR_shader_expect_assume",
       "VK_KHR_maintenance6",
       "VK_NV_descriptor_pool_overallocation",
+      "VK_KHR_video_encode_quantization_map",
       "VK_NV_raw_access_chains",
       "VK_KHR_shader_relaxed_extended_instruction",
       "VK_NV_command_buffer_inheritance",
@@ -450,16 +455,31 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_NV_shader_atomic_float16_vector",
       "VK_EXT_shader_replicated_composites",
       "VK_NV_ray_tracing_validation",
+      "VK_NV_cluster_acceleration_structure",
+      "VK_NV_partitioned_acceleration_structure",
       "VK_EXT_device_generated_commands",
+      "VK_KHR_maintenance8",
       "VK_MESA_image_alignment_control",
-      "VK_EXT_depth_clamp_control"
+      "VK_EXT_depth_clamp_control",
+      "VK_KHR_video_maintenance2",
+      "VK_HUAWEI_hdr_vivid",
+      "VK_NV_cooperative_matrix2",
+      "VK_ARM_pipeline_opacity_micromap",
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+      "VK_EXT_external_memory_metal",
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+      "VK_KHR_depth_clamp_zero_one",
+      "VK_EXT_vertex_attribute_robustness",
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+      "VK_NV_present_metering"
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
     };
     return deviceExtensions;
   }
 
   VULKAN_HPP_INLINE std::set<std::string> const & getInstanceExtensions()
   {
-    static std::set<std::string> instanceExtensions = {
+    static const std::set<std::string> instanceExtensions = {
       "VK_KHR_surface",
       "VK_KHR_display",
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
@@ -526,15 +546,16 @@ namespace VULKAN_HPP_NAMESPACE
       "VK_KHR_portability_enumeration",
       "VK_GOOGLE_surfaceless_query",
       "VK_LUNARG_direct_driver_loading",
-      "VK_EXT_layer_settings"
+      "VK_EXT_layer_settings",
+      "VK_NV_display_stereo"
     };
     return instanceExtensions;
   }
 
   VULKAN_HPP_INLINE std::map<std::string, std::vector<std::vector<std::string>>> const & getExtensionDepends( std::string const & extension )
   {
-    static std::map<std::string, std::vector<std::vector<std::string>>>                        noDependencies;
+    static const std::map<std::string, std::vector<std::vector<std::string>>>                        noDependencies;
-    static std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
+    static const std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
       { "VK_KHR_swapchain",
         { { "VK_VERSION_1_0",
             { {
@@ -992,17 +1013,15 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
       { "VK_AMDX_shader_enqueue",
         { { "VK_VERSION_1_0",
-            { {
-              "VK_KHR_get_physical_device_properties2",
-            } } },
-          { "VK_VERSION_1_1",
             { {
               "VK_KHR_synchronization2",
+              "VK_KHR_spirv_1_4",
+              "VK_EXT_extended_dynamic_state",
             } } },
           { "VK_VERSION_1_3",
             { {
+              "VK_KHR_maintenance5",
               "VK_KHR_pipeline_library",
-              "VK_KHR_spirv_1_4",
             } } } } },
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
       { "VK_EXT_inline_uniform_block",
@@ -1038,12 +1057,18 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_spirv_1_4",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
               "VK_KHR_acceleration_structure",
             } } } } },
       { "VK_KHR_ray_query",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_spirv_1_4",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
               "VK_KHR_acceleration_structure",
             } } } } },
       { "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } },
@@ -1346,6 +1371,9 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_1",
             { {
               "VK_KHR_vulkan_memory_model",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
               "VK_KHR_shader_maximal_reconvergence",
             } } } } },
       { "VK_KHR_spirv_1_4",
@@ -1512,7 +1540,8 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_map_memory2",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_4", { {} } } } },
       { "VK_EXT_shader_atomic_float2",
         { { "VK_VERSION_1_0",
             { {
@@ -1697,7 +1726,8 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_spirv_1_4",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_2", { {} } } } },
       { "VK_EXT_ycbcr_2plane_444_formats",
         { { "VK_VERSION_1_0",
             { {
@@ -1827,6 +1857,11 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_present_mode_fifo_latest_ready",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_swapchain",
+            } } } } },
 #if defined( VK_USE_PLATFORM_FUCHSIA )
       { "VK_FUCHSIA_external_memory",
         { { "VK_VERSION_1_0",
@@ -2047,6 +2082,11 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_NV_device_generated_commands",
             } } } } },
+      { "VK_NV_ray_tracing_linear_swept_spheres",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_ray_tracing_pipeline",
+            } } } } },
       { "VK_NV_linear_color_attachment",
         { { "VK_VERSION_1_0",
             { {
@@ -2165,7 +2205,8 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_maintenance5",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_4", { {} } } } },
       { "VK_QCOM_tile_properties",
         { { "VK_VERSION_1_0",
             { {
@@ -2193,7 +2234,8 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_maintenance3",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_legacy_vertex_attributes",
         { { "VK_VERSION_1_0",
             { {
@@ -2237,12 +2279,18 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_video_decode_av1",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_video_decode_queue",
             } } } } },
+      { "VK_KHR_video_encode_av1",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_encode_queue",
+            } } } } },
       { "VK_KHR_video_maintenance1",
         { { "VK_VERSION_1_0",
             { {
@@ -2252,7 +2300,8 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_maintenance6",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_4", { {} } } } },
       { "VK_QCOM_image_processing2",
         { { "VK_VERSION_1_0",
             { {
@@ -2338,13 +2387,41 @@ namespace VULKAN_HPP_NAMESPACE
           { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_display_stereo",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_display",
+              "VK_KHR_get_display_properties2",
+            } } } } },
+      { "VK_KHR_video_encode_quantization_map",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_encode_queue",
+              "VK_KHR_format_feature_flags2",
+            } } },
+          { "VK_VERSION_1_3", { {} } } } },
       { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_cluster_acceleration_structure",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_acceleration_structure",
+            } } } } },
+      { "VK_NV_partitioned_acceleration_structure",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_acceleration_structure",
+            } } } } },
       { "VK_EXT_device_generated_commands",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_buffer_device_address",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
               "VK_KHR_maintenance5",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_3", { {} } } } },
+      { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_MESA_image_alignment_control",
         { { "VK_VERSION_1_0",
             { {
@@ -2352,6 +2429,51 @@ namespace VULKAN_HPP_NAMESPACE
             } } },
           { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_depth_clamp_control",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_video_maintenance2",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_queue",
+            } } } } },
+      { "VK_HUAWEI_hdr_vivid",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_KHR_swapchain",
+              "VK_EXT_hdr_metadata",
+            } } } } },
+      { "VK_NV_cooperative_matrix2",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_cooperative_matrix",
+            } } } } },
+      { "VK_ARM_pipeline_opacity_micromap",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_EXT_opacity_micromap",
+            } } } } },
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+      { "VK_EXT_external_memory_metal",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_external_memory",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+      { "VK_KHR_depth_clamp_zero_one",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_vertex_attribute_robustness",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
@@ -2366,7 +2488,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                         std::string const & extension )
   {
 #if !defined( NDEBUG )
-    static std::set<std::string> versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3" };
+    static std::set<std::string> versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3", "VK_VERSION_1_4" };
     assert( versions.find( version ) != versions.end() );
 #endif
     static std::vector<std::vector<std::string>> noDependencies;
@@ -2393,13 +2515,13 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions()
   {
-    static std::map<std::string, std::string> obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } };
+    static const std::map<std::string, std::string> obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } };
     return obsoletedExtensions;
   }
 
   VULKAN_HPP_INLINE std::map<std::string, std::string> const & getPromotedExtensions()
   {
-    static std::map<std::string, std::string> promotedExtensions = {
+    static const std::map<std::string, std::string> promotedExtensions = {
       { "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" },
       { "VK_EXT_debug_marker", "VK_EXT_debug_utils" },
       { "VK_AMD_draw_indirect_count", "VK_KHR_draw_indirect_count" },
@@ -2412,12 +2534,14 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_KHR_device_group", "VK_VERSION_1_1" },
       { "VK_KHR_shader_draw_parameters", "VK_VERSION_1_1" },
       { "VK_EXT_texture_compression_astc_hdr", "VK_VERSION_1_3" },
+      { "VK_EXT_pipeline_robustness", "VK_VERSION_1_4" },
       { "VK_KHR_maintenance1", "VK_VERSION_1_1" },
       { "VK_KHR_device_group_creation", "VK_VERSION_1_1" },
       { "VK_KHR_external_memory_capabilities", "VK_VERSION_1_1" },
       { "VK_KHR_external_memory", "VK_VERSION_1_1" },
       { "VK_KHR_external_semaphore_capabilities", "VK_VERSION_1_1" },
       { "VK_KHR_external_semaphore", "VK_VERSION_1_1" },
+      { "VK_KHR_push_descriptor", "VK_VERSION_1_4" },
       { "VK_KHR_shader_float16_int8", "VK_VERSION_1_2" },
       { "VK_KHR_16bit_storage", "VK_VERSION_1_1" },
       { "VK_KHR_descriptor_update_template", "VK_VERSION_1_1" },
@@ -2445,6 +2569,7 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_KHR_8bit_storage", "VK_VERSION_1_2" },
       { "VK_KHR_shader_atomic_int64", "VK_VERSION_1_2" },
       { "VK_EXT_calibrated_timestamps", "VK_KHR_calibrated_timestamps" },
+      { "VK_KHR_global_priority", "VK_VERSION_1_4" },
       { "VK_EXT_vertex_attribute_divisor", "VK_KHR_vertex_attribute_divisor" },
       { "VK_EXT_pipeline_creation_feedback", "VK_VERSION_1_3" },
       { "VK_KHR_driver_properties", "VK_VERSION_1_2" },
@@ -2457,6 +2582,7 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_KHR_shader_terminate_invocation", "VK_VERSION_1_3" },
       { "VK_EXT_scalar_block_layout", "VK_VERSION_1_2" },
       { "VK_EXT_subgroup_size_control", "VK_VERSION_1_3" },
+      { "VK_KHR_dynamic_rendering_local_read", "VK_VERSION_1_4" },
       { "VK_KHR_spirv_1_4", "VK_VERSION_1_2" },
       { "VK_KHR_separate_depth_stencil_layouts", "VK_VERSION_1_2" },
       { "VK_EXT_tooling_info", "VK_VERSION_1_3" },
@@ -2467,6 +2593,8 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_EXT_host_query_reset", "VK_VERSION_1_2" },
       { "VK_EXT_index_type_uint8", "VK_KHR_index_type_uint8" },
       { "VK_EXT_extended_dynamic_state", "VK_VERSION_1_3" },
+      { "VK_EXT_host_image_copy", "VK_VERSION_1_4" },
+      { "VK_KHR_map_memory2", "VK_VERSION_1_4" },
       { "VK_EXT_shader_demote_to_helper_invocation", "VK_VERSION_1_3" },
       { "VK_KHR_shader_integer_dot_product", "VK_VERSION_1_3" },
       { "VK_EXT_texel_buffer_alignment", "VK_VERSION_1_3" },
@@ -2485,7 +2613,18 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_EXT_extended_dynamic_state2", "VK_VERSION_1_3" },
       { "VK_EXT_global_priority_query", "VK_KHR_global_priority" },
       { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" },
-      { "VK_KHR_maintenance4", "VK_VERSION_1_3" }
+      { "VK_KHR_maintenance4", "VK_VERSION_1_3" },
+      { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" },
+      { "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" },
+      { "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" },
+      { "VK_KHR_maintenance5", "VK_VERSION_1_4" },
+      { "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" },
+      { "VK_KHR_load_store_op_none", "VK_VERSION_1_4" },
+      { "VK_KHR_shader_float_controls2", "VK_VERSION_1_4" },
+      { "VK_KHR_index_type_uint8", "VK_VERSION_1_4" },
+      { "VK_KHR_line_rasterization", "VK_VERSION_1_4" },
+      { "VK_KHR_shader_expect_assume", "VK_VERSION_1_4" },
+      { "VK_KHR_maintenance6", "VK_VERSION_1_4" }
     };
     return promotedExtensions;
   }
@@ -2622,6 +2761,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_3";
     }
+    if ( extension == "VK_EXT_pipeline_robustness" )
+    {
+      return "VK_VERSION_1_4";
+    }
     if ( extension == "VK_KHR_maintenance1" )
     {
       return "VK_VERSION_1_1";
@@ -2646,6 +2789,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_1";
     }
+    if ( extension == "VK_KHR_push_descriptor" )
+    {
+      return "VK_VERSION_1_4";
+    }
     if ( extension == "VK_KHR_shader_float16_int8" )
     {
       return "VK_VERSION_1_2";
@@ -2754,6 +2901,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_KHR_calibrated_timestamps";
     }
+    if ( extension == "VK_KHR_global_priority" )
+    {
+      return "VK_VERSION_1_4";
+    }
     if ( extension == "VK_EXT_vertex_attribute_divisor" )
     {
       return "VK_KHR_vertex_attribute_divisor";
@@ -2802,6 +2953,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_3";
     }
+    if ( extension == "VK_KHR_dynamic_rendering_local_read" )
+    {
+      return "VK_VERSION_1_4";
+    }
     if ( extension == "VK_KHR_spirv_1_4" )
     {
       return "VK_VERSION_1_2";
@@ -2842,6 +2997,14 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_3";
     }
+    if ( extension == "VK_EXT_host_image_copy" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_map_memory2" )
+    {
+      return "VK_VERSION_1_4";
+    }
     if ( extension == "VK_EXT_shader_demote_to_helper_invocation" )
     {
       return "VK_VERSION_1_3";
@@ -2918,6 +3081,50 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_3";
     }
+    if ( extension == "VK_KHR_shader_subgroup_rotate" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_EXT_depth_clamp_zero_one" )
+    {
+      return "VK_KHR_depth_clamp_zero_one";
+    }
+    if ( extension == "VK_EXT_pipeline_protected_access" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_maintenance5" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_vertex_attribute_divisor" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_load_store_op_none" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_shader_float_controls2" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_index_type_uint8" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_line_rasterization" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_shader_expect_assume" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_maintenance6" )
+    {
+      return "VK_VERSION_1_4";
+    }
     return "";
   }
 
@@ -3081,7 +3288,7 @@ namespace VULKAN_HPP_NAMESPACE
         || ( extension == "VK_VALVE_mutable_descriptor_type" ) || ( extension == "VK_EXT_vertex_input_dynamic_state" ) ||
            ( extension == "VK_EXT_physical_device_drm" ) || ( extension == "VK_EXT_device_address_binding_report" ) ||
            ( extension == "VK_EXT_depth_clip_control" ) || ( extension == "VK_EXT_primitive_topology_list_restart" ) ||
-           ( extension == "VK_KHR_format_feature_flags2" )
+           ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" )
 #if defined( VK_USE_PLATFORM_FUCHSIA )
         || ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" )
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
@@ -3103,24 +3310,26 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_ARM_render_pass_striped" ) ||
            ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) ||
            ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_device_generated_commands_compute" ) ||
-           ( extension == "VK_NV_linear_color_attachment" ) || ( extension == "VK_KHR_shader_maximal_reconvergence" ) ||
+           ( extension == "VK_NV_ray_tracing_linear_swept_spheres" ) || ( extension == "VK_NV_linear_color_attachment" ) ||
-           ( extension == "VK_EXT_image_compression_control_swapchain" ) || ( extension == "VK_QCOM_image_processing" ) ||
+           ( extension == "VK_KHR_shader_maximal_reconvergence" ) || ( extension == "VK_EXT_image_compression_control_swapchain" ) ||
-           ( extension == "VK_EXT_nested_command_buffer" ) || ( extension == "VK_EXT_external_memory_acquire_unmodified" ) ||
+           ( extension == "VK_QCOM_image_processing" ) || ( extension == "VK_EXT_nested_command_buffer" ) ||
-           ( extension == "VK_EXT_extended_dynamic_state3" ) || ( extension == "VK_EXT_subpass_merge_feedback" ) ||
+           ( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
-           ( extension == "VK_EXT_shader_module_identifier" ) || ( extension == "VK_EXT_rasterization_order_attachment_access" ) ||
+           ( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
-           ( extension == "VK_NV_optical_flow" ) || ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
+           ( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) ||
+           ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
         || ( extension == "VK_ANDROID_external_format_resolve" )
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
         || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
            ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
            ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
-           ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
+           ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_cooperative_vector" ) ||
-           ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
+           ( extension == "VK_NV_extended_sparse_address_space" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
-           ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
+           ( extension == "VK_EXT_legacy_vertex_attributes" ) || ( extension == "VK_ARM_shader_core_builtins" ) ||
-           ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
+           ( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) ||
-           ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
+           ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
-           ( extension == "VK_KHR_compute_shader_derivatives" ) || ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_maintenance1" ) ||
+           ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) ||
+           ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_maintenance1" ) ||
            ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
            ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
            ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
@@ -3130,12 +3339,23 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
         || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
            ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
-           ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) ||
+           ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) ||
-           ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
+           ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) ||
-           ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
+           ( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) ||
-           ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
+           ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
-           ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_MESA_image_alignment_control" ) ||
+           ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) ||
-           ( extension == "VK_EXT_depth_clamp_control" );
+           ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
+           ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
+           ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
+           ( extension == "VK_ARM_pipeline_opacity_micromap" )
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+        || ( extension == "VK_EXT_external_memory_metal" )
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+        || ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" )
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+        || ( extension == "VK_NV_present_metering" )
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      ;
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@@ -3195,7 +3415,7 @@ namespace VULKAN_HPP_NAMESPACE
         || ( extension == "VK_QNX_screen_surface" )
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
         || ( extension == "VK_KHR_portability_enumeration" ) || ( extension == "VK_GOOGLE_surfaceless_query" ) ||
-           ( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_EXT_layer_settings" );
+           ( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_EXT_layer_settings" ) || ( extension == "VK_NV_display_stereo" );
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension )
@@ -3212,30 +3432,31 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
            ( extension == "VK_KHR_get_physical_device_properties2" ) || ( extension == "VK_KHR_device_group" ) ||
            ( extension == "VK_KHR_shader_draw_parameters" ) || ( extension == "VK_EXT_texture_compression_astc_hdr" ) ||
-           ( extension == "VK_KHR_maintenance1" ) || ( extension == "VK_KHR_device_group_creation" ) ||
+           ( extension == "VK_EXT_pipeline_robustness" ) || ( extension == "VK_KHR_maintenance1" ) || ( extension == "VK_KHR_device_group_creation" ) ||
            ( extension == "VK_KHR_external_memory_capabilities" ) || ( extension == "VK_KHR_external_memory" ) ||
            ( extension == "VK_KHR_external_semaphore_capabilities" ) || ( extension == "VK_KHR_external_semaphore" ) ||
-           ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) || ( extension == "VK_KHR_descriptor_update_template" ) ||
+           ( extension == "VK_KHR_push_descriptor" ) || ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) ||
-           ( extension == "VK_KHR_imageless_framebuffer" ) || ( extension == "VK_KHR_create_renderpass2" ) ||
+           ( extension == "VK_KHR_descriptor_update_template" ) || ( extension == "VK_KHR_imageless_framebuffer" ) ||
-           ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_external_fence" ) || ( extension == "VK_KHR_maintenance2" ) ||
+           ( extension == "VK_KHR_create_renderpass2" ) || ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_external_fence" ) ||
-           ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_KHR_dedicated_allocation" ) || ( extension == "VK_EXT_sampler_filter_minmax" ) ||
+           ( extension == "VK_KHR_maintenance2" ) || ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_KHR_dedicated_allocation" ) ||
-           ( extension == "VK_KHR_storage_buffer_storage_class" ) || ( extension == "VK_EXT_inline_uniform_block" ) ||
+           ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) ||
-           ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
+           ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_KHR_relaxed_block_layout" ) ||
-           ( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) ||
+           ( extension == "VK_KHR_get_memory_requirements2" ) || ( extension == "VK_KHR_image_format_list" ) ||
-           ( extension == "VK_EXT_descriptor_indexing" ) || ( extension == "VK_EXT_shader_viewport_index_layer" ) || ( extension == "VK_KHR_maintenance3" ) ||
+           ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) || ( extension == "VK_EXT_descriptor_indexing" ) ||
-           ( extension == "VK_KHR_draw_indirect_count" ) || ( extension == "VK_EXT_global_priority" ) ||
+           ( extension == "VK_EXT_shader_viewport_index_layer" ) || ( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) ||
-           ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
+           ( extension == "VK_EXT_global_priority" ) || ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
-           ( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) ||
+           ( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || ( extension == "VK_KHR_global_priority" ) ||
            ( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_EXT_pipeline_creation_feedback" ) ||
            ( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) ||
            ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) ||
            ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_KHR_vulkan_memory_model" ) ||
            ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_scalar_block_layout" ) ||
-           ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_KHR_separate_depth_stencil_layouts" ) ||
+           ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_KHR_spirv_1_4" ) ||
-           ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) ||
+           ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_tooling_info" ) ||
-           ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || ( extension == "VK_KHR_buffer_device_address" ) ||
+           ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_uniform_buffer_standard_layout" ) ||
-           ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) ||
+           ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) ||
-           ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
+           ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_host_image_copy" ) ||
+           ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
            ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) ||
            ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) ||
            ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) ||
@@ -3243,7 +3464,12 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) ||
            ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) ||
            ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
-           ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" );
+           ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) ||
+           ( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) ||
+           ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
+           ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
+           ( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
+           ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" );
   }
 }  // namespace VULKAN_HPP_NAMESPACE
 

include/vulkan/vulkan/vulkan_format_traits.hpp

@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -354,6 +354,8 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return 16;
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return 16;
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return 16;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 2;
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return 8;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return 8;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return 8;
@@ -363,8 +365,6 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 8;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 8;
       case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 4;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 2;
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
 
       default: VULKAN_HPP_ASSERT( false ); return 0;
     }
@@ -613,6 +613,8 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return "ASTC_10x10";
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return "ASTC_12x10";
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return "ASTC_12x12";
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return "16-bit";
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return "8-bit alpha";
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return "PVRTC1_2BPP";
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return "PVRTC1_4BPP";
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return "PVRTC2_2BPP";
@@ -622,8 +624,6 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return "PVRTC2_2BPP";
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return "PVRTC2_4BPP";
       case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return "32-bit";
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return "16-bit";
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return "8-bit alpha";
 
       default: VULKAN_HPP_ASSERT( false ); return "";
     }
@@ -2005,14 +2005,7 @@ namespace VULKAN_HPP_NAMESPACE
           case 3: return 4;
           default: VULKAN_HPP_ASSERT( false ); return 0;
         }
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16:
-        switch ( component )
-        {
-          case 0: return 16;
-          case 1: return 16;
-          default: VULKAN_HPP_ASSERT( false ); return 0;
-        }
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
         switch ( component )
         {
           case 0: return 1;
@@ -2021,12 +2014,19 @@ namespace VULKAN_HPP_NAMESPACE
           case 3: return 5;
           default: VULKAN_HPP_ASSERT( false ); return 0;
         }
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm:
         switch ( component )
         {
           case 0: return 8;
           default: VULKAN_HPP_ASSERT( false ); return 0;
         }
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
+        switch ( component )
+        {
+          case 0: return 16;
+          case 1: return 16;
+          default: VULKAN_HPP_ASSERT( false ); return 0;
+        }
 
       default: return 0;
     }
@@ -2275,6 +2275,8 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return 4;
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return 4;
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return 4;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 4;
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return 4;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return 4;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return 4;
@@ -2284,8 +2286,6 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 4;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 4;
       case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 2;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 4;
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
 
       default: return 0;
     }
@@ -4227,6 +4227,21 @@ namespace VULKAN_HPP_NAMESPACE
           case 3: return "A";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16:
+        switch ( component )
+        {
+          case 0: return "A";
+          case 1: return "B";
+          case 2: return "G";
+          case 3: return "R";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm:
+        switch ( component )
+        {
+          case 0: return "A";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG:
         switch ( component )
         {
@@ -4306,21 +4321,6 @@ namespace VULKAN_HPP_NAMESPACE
           case 1: return "G";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
-        switch ( component )
-        {
-          case 0: return "A";
-          case 1: return "B";
-          case 2: return "G";
-          case 3: return "R";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
-        switch ( component )
-        {
-          case 0: return "A";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }
 
       default: return "";
     }
@@ -6262,6 +6262,21 @@ namespace VULKAN_HPP_NAMESPACE
           case 3: return "SFLOAT";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16:
+        switch ( component )
+        {
+          case 0: return "UNORM";
+          case 1: return "UNORM";
+          case 2: return "UNORM";
+          case 3: return "UNORM";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm:
+        switch ( component )
+        {
+          case 0: return "UNORM";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG:
         switch ( component )
         {
@@ -6341,21 +6356,6 @@ namespace VULKAN_HPP_NAMESPACE
           case 1: return "SFIXED5";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
-        switch ( component )
-        {
-          case 0: return "UNORM";
-          case 1: return "UNORM";
-          case 2: return "UNORM";
-          case 3: return "UNORM";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
-        switch ( component )
-        {
-          case 0: return "UNORM";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }
 
       default: return "";
     }
@@ -6796,7 +6796,7 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: return 16;
       case VULKAN_HPP_NAMESPACE::Format::eA4R4G4B4UnormPack16: return 16;
       case VULKAN_HPP_NAMESPACE::Format::eA4B4G4R4UnormPack16: return 16;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 16;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 16;
 
       default: return 0;
     }
@@ -7649,6 +7649,8 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return 100;
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return 120;
       case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return 144;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 1;
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return 1;
@@ -7658,8 +7660,6 @@ namespace VULKAN_HPP_NAMESPACE
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 1;
       case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 1;
       case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 1;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 1;
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;
 
       default: VULKAN_HPP_ASSERT( false ); return 0;
     }

include/vulkan/vulkan/vulkan_fuchsia.h

@@ -2,7 +2,7 @@
 #define VULKAN_FUCHSIA_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_ggp.h

@@ -2,7 +2,7 @@
 #define VULKAN_GGP_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_hpp_macros.hpp

@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -256,34 +256,41 @@
 #endif
 
 namespace VULKAN_HPP_NAMESPACE
+{
+  namespace detail
   {
     class DispatchLoaderDynamic;
+
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
+#  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+    extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
+#  endif
+#endif
+  }  // namespace detail
 }  // namespace VULKAN_HPP_NAMESPACE
 
 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
 #  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic
 #    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE                       \
       namespace VULKAN_HPP_NAMESPACE                                                 \
       {                                                                              \
-        VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+        namespace detail                                                             \
+        {                                                                            \
+          VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+        }                                                                            \
       }
-
-namespace VULKAN_HPP_NAMESPACE
-{
-  extern VULKAN_HPP_STORAGE_API VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic;
-}  // namespace VULKAN_HPP_NAMESPACE
 #  else
-#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic()
 #    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
 #  endif
 #endif
 
 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
 #  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic
 #  else
-#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic
 #  endif
 #endif
 

include/vulkan/vulkan/vulkan_ios.h

@@ -2,7 +2,7 @@
 #define VULKAN_IOS_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_macos.h

@@ -2,7 +2,7 @@
 #define VULKAN_MACOS_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_metal.h

@@ -2,7 +2,7 @@
 #define VULKAN_METAL_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -188,6 +188,47 @@ VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
     VkExportMetalObjectsInfoEXT*                pMetalObjectsInfo);
 #endif
 
+
+// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_external_memory_metal 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal"
+typedef struct VkImportMemoryMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    void*                                 handle;
+} VkImportMemoryMetalHandleInfoEXT;
+
+typedef struct VkMemoryMetalHandlePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryMetalHandlePropertiesEXT;
+
+typedef struct VkMemoryGetMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetMetalHandleInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(
+    VkDevice                                    device,
+    const VkMemoryGetMetalHandleInfoEXT*        pGetMetalHandleInfo,
+    void**                                      pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    const void*                                 pHandle,
+    VkMemoryMetalHandlePropertiesEXT*           pMemoryMetalHandleProperties);
+#endif
+
 #ifdef __cplusplus
 }
 #endif

include/vulkan/vulkan/vulkan_screen.h

@@ -2,7 +2,7 @@
 #define VULKAN_SCREEN_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_shared.hpp

@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -308,13 +308,16 @@ namespace VULKAN_HPP_NAMESPACE
     using BaseType::internalDestroy;
   };
 
-  template <typename HandleType>
+  namespace detail
-  class SharedHandleTraits;
+  {
 
 // Silence the function cast warnings.
 #  if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wcast-function-type"
+#  elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wcast-function-type"
 #  endif
 
     template <typename HandleType>
@@ -356,8 +359,8 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy             = nullptr;
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
-    const DispatchLoaderBase *                     m_dispatch            = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
       Optional<const AllocationCallbacks>                    m_allocationCallbacks = nullptr;
     };
 
@@ -387,8 +390,8 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy             = nullptr;
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
-    const DispatchLoaderBase *                     m_dispatch            = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
       Optional<const AllocationCallbacks>                    m_allocationCallbacks = nullptr;
     };
 
@@ -416,8 +419,8 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy  = nullptr;
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
-    const DispatchLoaderBase *                     m_dispatch = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
     };
 
     template <typename HandleType, typename PoolType>
@@ -452,15 +455,19 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy  = nullptr;
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
-    const DispatchLoaderBase *                     m_dispatch = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
       SharedHandle<PoolType>                                 m_pool{};
     };
 
 #  if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
 #    pragma GCC diagnostic pop
+#  elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
+#    pragma clang diagnostic pop
 #  endif
 
+  }  // namespace detail
+
   //======================
   //=== SHARED HANDLEs ===
   //======================
@@ -471,7 +478,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = NoDestructor;
-    using deleter        = ObjectDestroyShared<Instance>;
+    using deleter        = detail::ObjectDestroyShared<Instance>;
   };
 
   using SharedInstance = SharedHandle<Instance>;
@@ -481,7 +488,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = NoDestructor;
-    using deleter        = ObjectDestroyShared<Device>;
+    using deleter        = detail::ObjectDestroyShared<Device>;
   };
 
   using SharedDevice = SharedHandle<Device>;
@@ -491,7 +498,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectFreeShared<DeviceMemory>;
+    using deleter        = detail::ObjectFreeShared<DeviceMemory>;
   };
 
   using SharedDeviceMemory = SharedHandle<DeviceMemory>;
@@ -501,7 +508,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Fence>;
+    using deleter        = detail::ObjectDestroyShared<Fence>;
   };
 
   using SharedFence = SharedHandle<Fence>;
@@ -511,7 +518,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Semaphore>;
+    using deleter        = detail::ObjectDestroyShared<Semaphore>;
   };
 
   using SharedSemaphore = SharedHandle<Semaphore>;
@@ -521,7 +528,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Event>;
+    using deleter        = detail::ObjectDestroyShared<Event>;
   };
 
   using SharedEvent = SharedHandle<Event>;
@@ -531,7 +538,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<QueryPool>;
+    using deleter        = detail::ObjectDestroyShared<QueryPool>;
   };
 
   using SharedQueryPool = SharedHandle<QueryPool>;
@@ -541,7 +548,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Buffer>;
+    using deleter        = detail::ObjectDestroyShared<Buffer>;
   };
 
   using SharedBuffer = SharedHandle<Buffer>;
@@ -551,7 +558,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<BufferView>;
+    using deleter        = detail::ObjectDestroyShared<BufferView>;
   };
 
   using SharedBufferView = SharedHandle<BufferView>;
@@ -561,7 +568,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Image>;
+    using deleter        = detail::ObjectDestroyShared<Image>;
   };
 
   using SharedImage = SharedHandle<Image>;
@@ -571,7 +578,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ImageView>;
+    using deleter        = detail::ObjectDestroyShared<ImageView>;
   };
 
   using SharedImageView = SharedHandle<ImageView>;
@@ -581,7 +588,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ShaderModule>;
+    using deleter        = detail::ObjectDestroyShared<ShaderModule>;
   };
 
   using SharedShaderModule = SharedHandle<ShaderModule>;
@@ -591,7 +598,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PipelineCache>;
+    using deleter        = detail::ObjectDestroyShared<PipelineCache>;
   };
 
   using SharedPipelineCache = SharedHandle<PipelineCache>;
@@ -601,7 +608,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Pipeline>;
+    using deleter        = detail::ObjectDestroyShared<Pipeline>;
   };
 
   using SharedPipeline = SharedHandle<Pipeline>;
@@ -611,7 +618,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PipelineLayout>;
+    using deleter        = detail::ObjectDestroyShared<PipelineLayout>;
   };
 
   using SharedPipelineLayout = SharedHandle<PipelineLayout>;
@@ -621,7 +628,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Sampler>;
+    using deleter        = detail::ObjectDestroyShared<Sampler>;
   };
 
   using SharedSampler = SharedHandle<Sampler>;
@@ -631,7 +638,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DescriptorPool>;
+    using deleter        = detail::ObjectDestroyShared<DescriptorPool>;
   };
 
   using SharedDescriptorPool = SharedHandle<DescriptorPool>;
@@ -641,7 +648,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = PoolFreeShared<DescriptorSet, DescriptorPool>;
+    using deleter        = detail::PoolFreeShared<DescriptorSet, DescriptorPool>;
   };
 
   using SharedDescriptorSet = SharedHandle<DescriptorSet>;
@@ -651,7 +658,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DescriptorSetLayout>;
+    using deleter        = detail::ObjectDestroyShared<DescriptorSetLayout>;
   };
 
   using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
@@ -661,7 +668,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Framebuffer>;
+    using deleter        = detail::ObjectDestroyShared<Framebuffer>;
   };
 
   using SharedFramebuffer = SharedHandle<Framebuffer>;
@@ -671,7 +678,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<RenderPass>;
+    using deleter        = detail::ObjectDestroyShared<RenderPass>;
   };
 
   using SharedRenderPass = SharedHandle<RenderPass>;
@@ -681,7 +688,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CommandPool>;
+    using deleter        = detail::ObjectDestroyShared<CommandPool>;
   };
 
   using SharedCommandPool = SharedHandle<CommandPool>;
@@ -691,7 +698,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = PoolFreeShared<CommandBuffer, CommandPool>;
+    using deleter        = detail::PoolFreeShared<CommandBuffer, CommandPool>;
   };
 
   using SharedCommandBuffer = SharedHandle<CommandBuffer>;
@@ -702,7 +709,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<SamplerYcbcrConversion>;
+    using deleter        = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
   };
 
   using SharedSamplerYcbcrConversion    = SharedHandle<SamplerYcbcrConversion>;
@@ -713,7 +720,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DescriptorUpdateTemplate>;
+    using deleter        = detail::ObjectDestroyShared<DescriptorUpdateTemplate>;
   };
 
   using SharedDescriptorUpdateTemplate    = SharedHandle<DescriptorUpdateTemplate>;
@@ -725,7 +732,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PrivateDataSlot>;
+    using deleter        = detail::ObjectDestroyShared<PrivateDataSlot>;
   };
 
   using SharedPrivateDataSlot    = SharedHandle<PrivateDataSlot>;
@@ -737,7 +744,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Instance;
-    using deleter        = ObjectDestroyShared<SurfaceKHR>;
+    using deleter        = detail::ObjectDestroyShared<SurfaceKHR>;
   };
 
   using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
@@ -748,7 +755,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<SwapchainKHR>;
+    using deleter        = detail::ObjectDestroyShared<SwapchainKHR>;
   };
 
   using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
@@ -759,7 +766,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = PhysicalDevice;
-    using deleter        = ObjectDestroyShared<DisplayKHR>;
+    using deleter        = detail::ObjectDestroyShared<DisplayKHR>;
   };
 
   using SharedDisplayKHR = SharedHandle<DisplayKHR>;
@@ -770,7 +777,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Instance;
-    using deleter        = ObjectDestroyShared<DebugReportCallbackEXT>;
+    using deleter        = detail::ObjectDestroyShared<DebugReportCallbackEXT>;
   };
 
   using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
@@ -781,7 +788,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<VideoSessionKHR>;
+    using deleter        = detail::ObjectDestroyShared<VideoSessionKHR>;
   };
 
   using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
@@ -791,7 +798,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<VideoSessionParametersKHR>;
+    using deleter        = detail::ObjectDestroyShared<VideoSessionParametersKHR>;
   };
 
   using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
@@ -802,7 +809,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CuModuleNVX>;
+    using deleter        = detail::ObjectDestroyShared<CuModuleNVX>;
   };
 
   using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
@@ -812,7 +819,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CuFunctionNVX>;
+    using deleter        = detail::ObjectDestroyShared<CuFunctionNVX>;
   };
 
   using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
@@ -823,7 +830,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Instance;
-    using deleter        = ObjectDestroyShared<DebugUtilsMessengerEXT>;
+    using deleter        = detail::ObjectDestroyShared<DebugUtilsMessengerEXT>;
   };
 
   using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
@@ -834,7 +841,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<AccelerationStructureKHR>;
+    using deleter        = detail::ObjectDestroyShared<AccelerationStructureKHR>;
   };
 
   using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
@@ -845,7 +852,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ValidationCacheEXT>;
+    using deleter        = detail::ObjectDestroyShared<ValidationCacheEXT>;
   };
 
   using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
@@ -856,7 +863,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<AccelerationStructureNV>;
+    using deleter        = detail::ObjectDestroyShared<AccelerationStructureNV>;
   };
 
   using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
@@ -867,7 +874,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PerformanceConfigurationINTEL>;
+    using deleter        = detail::ObjectDestroyShared<PerformanceConfigurationINTEL>;
   };
 
   using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
@@ -878,7 +885,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DeferredOperationKHR>;
+    using deleter        = detail::ObjectDestroyShared<DeferredOperationKHR>;
   };
 
   using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
@@ -889,7 +896,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<IndirectCommandsLayoutNV>;
+    using deleter        = detail::ObjectDestroyShared<IndirectCommandsLayoutNV>;
   };
 
   using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
@@ -901,7 +908,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CudaModuleNV>;
+    using deleter        = detail::ObjectDestroyShared<CudaModuleNV>;
   };
 
   using SharedCudaModuleNV = SharedHandle<CudaModuleNV>;
@@ -911,7 +918,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CudaFunctionNV>;
+    using deleter        = detail::ObjectDestroyShared<CudaFunctionNV>;
   };
 
   using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>;
@@ -924,7 +931,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<BufferCollectionFUCHSIA>;
+    using deleter        = detail::ObjectDestroyShared<BufferCollectionFUCHSIA>;
   };
 
   using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
@@ -936,7 +943,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<MicromapEXT>;
+    using deleter        = detail::ObjectDestroyShared<MicromapEXT>;
   };
 
   using SharedMicromapEXT = SharedHandle<MicromapEXT>;
@@ -947,7 +954,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<OpticalFlowSessionNV>;
+    using deleter        = detail::ObjectDestroyShared<OpticalFlowSessionNV>;
   };
 
   using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
@@ -958,7 +965,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ShaderEXT>;
+    using deleter        = detail::ObjectDestroyShared<ShaderEXT>;
   };
 
   using SharedShaderEXT = SharedHandle<ShaderEXT>;
@@ -969,7 +976,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PipelineBinaryKHR>;
+    using deleter        = detail::ObjectDestroyShared<PipelineBinaryKHR>;
   };
 
   using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;
@@ -980,7 +987,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<IndirectCommandsLayoutEXT>;
+    using deleter        = detail::ObjectDestroyShared<IndirectCommandsLayoutEXT>;
   };
 
   using SharedIndirectCommandsLayoutEXT = SharedHandle<IndirectCommandsLayoutEXT>;
@@ -990,7 +997,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
   public:
     using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<IndirectExecutionSetEXT>;
+    using deleter        = detail::ObjectDestroyShared<IndirectExecutionSetEXT>;
   };
 
   using SharedIndirectExecutionSetEXT = SharedHandle<IndirectExecutionSetEXT>;

include/vulkan/vulkan/vulkan_vi.h

@@ -2,7 +2,7 @@
 #define VULKAN_VI_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_video.hpp

@@ -1,4 +1,4 @@
-// Copyright 2021-2024 The Khronos Group Inc.
+// Copyright 2021-2025 The Khronos Group Inc.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
 
@@ -7,8 +7,15 @@
 #ifndef VULKAN_VIDEO_HPP
 #define VULKAN_VIDEO_HPP
 
+// clang-format off
+#include <vulkan/vulkan.hpp>
+// clang-format on
+
 #include <vk_video/vulkan_video_codec_av1std.h>
 #include <vk_video/vulkan_video_codec_av1std_decode.h>
+#if ( 301 < VK_HEADER_VERSION )
+#  include <vk_video/vulkan_video_codec_av1std_encode.h>
+#endif
 #include <vk_video/vulkan_video_codec_h264std.h>
 #include <vk_video/vulkan_video_codec_h264std_decode.h>
 #include <vk_video/vulkan_video_codec_h264std_encode.h>
@@ -16,7 +23,6 @@
 #include <vk_video/vulkan_video_codec_h265std_decode.h>
 #include <vk_video/vulkan_video_codec_h265std_encode.h>
 #include <vk_video/vulkan_video_codecs_common.h>
-#include <vulkan/vulkan.hpp>
 
 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE )
 #  define VULKAN_HPP_VIDEO_NAMESPACE video
@@ -359,7 +365,9 @@ namespace VULKAN_HPP_NAMESPACE
     enum class AV1ColorPrimaries
     {
       eBt709       = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709,
-      eBtUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED,
+      eUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
+      eBtUnspecified VULKAN_HPP_DEPRECATED_17( "eBtUnspecified is deprecated, eUnspecified should be used instead." ) =
+        STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED,
       eBt470M      = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M,
       eBt470BG     = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G,
       eBt601       = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601,
@@ -3711,6 +3719,339 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES>   SavedOrderHints  = {};
     };
 
+    //=== vulkan_video_codec_av1std_encode ===
+
+    struct EncodeAV1DecoderModelInfo
+    {
+      using NativeType = StdVideoEncodeAV1DecoderModelInfo;
+
+      operator StdVideoEncodeAV1DecoderModelInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1DecoderModelInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1DecoderModelInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1DecoderModelInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) &&
+               ( buffer_removal_time_length_minus_1 == rhs.buffer_removal_time_length_minus_1 ) &&
+               ( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && ( reserved1 == rhs.reserved1 ) &&
+               ( num_units_in_decoding_tick == rhs.num_units_in_decoding_tick );
+      }
+
+      bool operator!=( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint8_t  buffer_delay_length_minus_1            = {};
+      uint8_t  buffer_removal_time_length_minus_1     = {};
+      uint8_t  frame_presentation_time_length_minus_1 = {};
+      uint8_t  reserved1                              = {};
+      uint32_t num_units_in_decoding_tick             = {};
+    };
+
+    struct EncodeAV1ExtensionHeader
+    {
+      using NativeType = StdVideoEncodeAV1ExtensionHeader;
+
+      operator StdVideoEncodeAV1ExtensionHeader const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1ExtensionHeader *>( this );
+      }
+
+      operator StdVideoEncodeAV1ExtensionHeader &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1ExtensionHeader *>( this );
+      }
+
+      bool operator==( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( temporal_id == rhs.temporal_id ) && ( spatial_id == rhs.spatial_id );
+      }
+
+      bool operator!=( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint8_t temporal_id = {};
+      uint8_t spatial_id  = {};
+    };
+
+    struct EncodeAV1OperatingPointInfoFlags
+    {
+      using NativeType = StdVideoEncodeAV1OperatingPointInfoFlags;
+
+      operator StdVideoEncodeAV1OperatingPointInfoFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1OperatingPointInfoFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
+      }
+
+      bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) &&
+               ( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint32_t decoder_model_present_for_this_op         : 1;
+      uint32_t low_delay_mode_flag                       : 1;
+      uint32_t initial_display_delay_present_for_this_op : 1;
+      uint32_t reserved                                  : 29;
+    };
+
+    struct EncodeAV1OperatingPointInfo
+    {
+      using NativeType = StdVideoEncodeAV1OperatingPointInfo;
+
+      operator StdVideoEncodeAV1OperatingPointInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1OperatingPointInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) &&
+               ( seq_tier == rhs.seq_tier ) && ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && ( encoder_buffer_delay == rhs.encoder_buffer_delay ) &&
+               ( initial_display_delay_minus_1 == rhs.initial_display_delay_minus_1 );
+      }
+
+      bool operator!=( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags flags                         = {};
+      uint16_t                                                                           operating_point_idc           = {};
+      uint8_t                                                                            seq_level_idx                 = {};
+      uint8_t                                                                            seq_tier                      = {};
+      uint32_t                                                                           decoder_buffer_delay          = {};
+      uint32_t                                                                           encoder_buffer_delay          = {};
+      uint8_t                                                                            initial_display_delay_minus_1 = {};
+    };
+
+    struct EncodeAV1PictureInfoFlags
+    {
+      using NativeType = StdVideoEncodeAV1PictureInfoFlags;
+
+      operator StdVideoEncodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1PictureInfoFlags *>( this );
+      }
+
+      bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) &&
+               ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) &&
+               ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) &&
+               ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) &&
+               ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) &&
+               ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) &&
+               ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) &&
+               ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) &&
+               ( reduced_tx_set == rhs.reduced_tx_set ) && ( skip_mode_present == rhs.skip_mode_present ) && ( delta_q_present == rhs.delta_q_present ) &&
+               ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) &&
+               ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) &&
+               ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) &&
+               ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( show_frame == rhs.show_frame ) &&
+               ( showable_frame == rhs.showable_frame ) && ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      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 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 show_frame                       : 1;
+      uint32_t showable_frame                   : 1;
+      uint32_t reserved                         : 3;
+    };
+
+    struct EncodeAV1PictureInfo
+    {
+      using NativeType = StdVideoEncodeAV1PictureInfo;
+
+      operator StdVideoEncodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1PictureInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1PictureInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) &&
+               ( current_frame_id == rhs.current_frame_id ) && ( order_hint == rhs.order_hint ) && ( primary_ref_frame == rhs.primary_ref_frame ) &&
+               ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( coded_denom == rhs.coded_denom ) &&
+               ( render_width_minus_1 == rhs.render_width_minus_1 ) && ( render_height_minus_1 == rhs.render_height_minus_1 ) &&
+               ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) &&
+               ( delta_lf_res == rhs.delta_lf_res ) && ( ref_order_hint == rhs.ref_order_hint ) && ( ref_frame_idx == rhs.ref_frame_idx ) &&
+               ( reserved1 == rhs.reserved1 ) && ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && ( pTileInfo == rhs.pTileInfo ) &&
+               ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && ( pLoopFilter == rhs.pLoopFilter ) &&
+               ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && ( pGlobalMotion == rhs.pGlobalMotion ) &&
+               ( pExtensionHeader == rhs.pExtensionHeader ) && ( pBufferRemovalTimes == rhs.pBufferRemovalTimes );
+      }
+
+      bool operator!=( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags flags = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
+      uint32_t                                                       frame_presentation_time = {};
+      uint32_t                                                       current_frame_id        = {};
+      uint8_t                                                        order_hint              = {};
+      uint8_t                                                        primary_ref_frame       = {};
+      uint8_t                                                        refresh_frame_flags     = {};
+      uint8_t                                                        coded_denom             = {};
+      uint16_t                                                       render_width_minus_1    = {};
+      uint16_t                                                       render_height_minus_1   = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter =
+        VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4;
+      uint8_t                                                     delta_q_res  = {};
+      uint8_t                                                     delta_lf_res = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES>        ref_order_hint         = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_REFS_PER_FRAME>         ref_frame_idx          = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3>                                   reserved1              = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_REFS_PER_FRAME>       delta_frame_id_minus_1 = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo *              pTileInfo              = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization *          pQuantization          = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation *          pSegmentation          = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter *            pLoopFilter            = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF *                  pCDEF                  = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration *       pLoopRestoration       = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion *          pGlobalMotion          = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader       = {};
+      const uint32_t *                                                                   pBufferRemovalTimes    = {};
+    };
+
+    struct EncodeAV1ReferenceInfoFlags
+    {
+      using NativeType = StdVideoEncodeAV1ReferenceInfoFlags;
+
+      operator StdVideoEncodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfoFlags *>( this );
+      }
+
+      bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
+               ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint32_t disable_frame_end_update_cdf : 1;
+      uint32_t segmentation_enabled         : 1;
+      uint32_t reserved                     : 30;
+    };
+
+    struct EncodeAV1ReferenceInfo
+    {
+      using NativeType = StdVideoEncodeAV1ReferenceInfo;
+
+      operator StdVideoEncodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) &&
+               ( reserved1 == rhs.reserved1 ) && ( pExtensionHeader == rhs.pExtensionHeader );
+      }
+
+      bool operator!=( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags flags      = {};
+      uint32_t                                                                      RefFrameId = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
+      uint8_t                                                        OrderHint  = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3>               reserved1  = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
+    };
+
   }  // namespace VULKAN_HPP_VIDEO_NAMESPACE
 }  // namespace VULKAN_HPP_NAMESPACE
 #endif

include/vulkan/vulkan/vulkan_wayland.h

@@ -2,7 +2,7 @@
 #define VULKAN_WAYLAND_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_win32.h

@@ -2,7 +2,7 @@
 #define VULKAN_WIN32_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_xcb.h

@@ -2,7 +2,7 @@
 #define VULKAN_XCB_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_xlib.h

@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */

include/vulkan/vulkan/vulkan_xlib_xrandr.h

@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_XRANDR_H_ 1
 
 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */