build: Update to header 1.4.306

layers/VkLayer_khronos_validation.json.in

@@ -4,7 +4,7 @@
         "name": "@JSON_LAYER_NAME@",
         "type": "GLOBAL",
         "library_path": "@JSON_LIBRARY_PATH@",
-        "api_version": "1.4.305",
+        "api_version": "1.4.306",
         "implementation_version": "1",
         "description": "Khronos Validation Layer",
         "introduction": "The main, comprehensive Khronos validation layer.\n\nVulkan is an Explicit API, enabling direct control over how GPUs actually work. By design, minimal error checking is done inside a Vulkan driver. Applications have full control and responsibility for correct operation. Any errors in how Vulkan is used can result in a crash. \n\nThe Khronos Validation Layer can be enabled to assist development by enabling developers to verify their applications correctly use the Vulkan API.",

layers/vulkan/generated/best_practices.cpp

@@ -3089,6 +3089,29 @@ void BestPractices::PostCallRecordGetPhysicalDeviceCooperativeMatrixFlexibleDime
     }
 }
 
+#ifdef VK_USE_PLATFORM_METAL_EXT
+void BestPractices::PostCallRecordGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
+                                                          void** pHandle, const RecordObject& record_obj) {
+    BaseClass::PostCallRecordGetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle, record_obj);
+
+    if (record_obj.result < VK_SUCCESS) {
+        LogErrorCode(record_obj);
+    }
+}
+
+void BestPractices::PostCallRecordGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+                                                                    const void* pHandle,
+                                                                    VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties,
+                                                                    const RecordObject& record_obj) {
+    BaseClass::PostCallRecordGetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties,
+                                                               record_obj);
+
+    if (record_obj.result < VK_SUCCESS) {
+        LogErrorCode(record_obj);
+    }
+}
+#endif  // VK_USE_PLATFORM_METAL_EXT
+
 void BestPractices::PostCallRecordCreateAccelerationStructureKHR(VkDevice device,
                                                                  const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
                                                                  const VkAllocationCallbacks* pAllocator,

layers/vulkan/generated/best_practices.h

@@ -1026,6 +1026,16 @@ void PostCallRecordGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertie
     VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties,
     const RecordObject& record_obj) override;
 
+#ifdef VK_USE_PLATFORM_METAL_EXT
+void PostCallRecordGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
+                                           void** pHandle, const RecordObject& record_obj) override;
+
+void PostCallRecordGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+                                                     const void* pHandle,
+                                                     VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties,
+                                                     const RecordObject& record_obj) override;
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
 void PostCallRecordCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
                                                   const VkAllocationCallbacks* pAllocator,
                                                   VkAccelerationStructureKHR* pAccelerationStructure,

layers/vulkan/generated/chassis.cpp

@@ -25691,6 +25691,90 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixFlexibleDimensi
     return result;
 }
 
+#ifdef VK_USE_PLATFORM_METAL_EXT
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
+                                                       void** pHandle) {
+    VVL_ZoneScoped;
+
+    auto device_dispatch = vvl::dispatch::GetData(device);
+    bool skip = false;
+    ErrorObject error_obj(vvl::Func::vkGetMemoryMetalHandleEXT, VulkanTypedHandle(device, kVulkanObjectTypeDevice));
+    {
+        VVL_ZoneScopedN("PreCallValidate");
+        for (const auto& vo : device_dispatch->intercept_vectors[InterceptIdPreCallValidateGetMemoryMetalHandleEXT]) {
+            auto lock = vo->ReadLock();
+            skip |= vo->PreCallValidateGetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle, error_obj);
+            if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+        }
+    }
+    RecordObject record_obj(vvl::Func::vkGetMemoryMetalHandleEXT);
+    {
+        VVL_ZoneScopedN("PreCallRecord");
+        for (auto& vo : device_dispatch->intercept_vectors[InterceptIdPreCallRecordGetMemoryMetalHandleEXT]) {
+            auto lock = vo->WriteLock();
+            vo->PreCallRecordGetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle, record_obj);
+        }
+    }
+    VkResult result;
+    {
+        VVL_ZoneScopedN("Dispatch");
+        result = device_dispatch->GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle);
+    }
+    record_obj.result = result;
+    {
+        VVL_ZoneScopedN("PostCallRecord");
+        for (auto& vo : device_dispatch->intercept_vectors[InterceptIdPostCallRecordGetMemoryMetalHandleEXT]) {
+            auto lock = vo->WriteLock();
+            vo->PostCallRecordGetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle, record_obj);
+        }
+    }
+    return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+                                                                 const void* pHandle,
+                                                                 VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) {
+    VVL_ZoneScoped;
+
+    auto device_dispatch = vvl::dispatch::GetData(device);
+    bool skip = false;
+    ErrorObject error_obj(vvl::Func::vkGetMemoryMetalHandlePropertiesEXT, VulkanTypedHandle(device, kVulkanObjectTypeDevice));
+    {
+        VVL_ZoneScopedN("PreCallValidate");
+        for (const auto& vo : device_dispatch->intercept_vectors[InterceptIdPreCallValidateGetMemoryMetalHandlePropertiesEXT]) {
+            auto lock = vo->ReadLock();
+            skip |= vo->PreCallValidateGetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties,
+                                                                         error_obj);
+            if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+        }
+    }
+    RecordObject record_obj(vvl::Func::vkGetMemoryMetalHandlePropertiesEXT);
+    {
+        VVL_ZoneScopedN("PreCallRecord");
+        for (auto& vo : device_dispatch->intercept_vectors[InterceptIdPreCallRecordGetMemoryMetalHandlePropertiesEXT]) {
+            auto lock = vo->WriteLock();
+            vo->PreCallRecordGetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties,
+                                                               record_obj);
+        }
+    }
+    VkResult result;
+    {
+        VVL_ZoneScopedN("Dispatch");
+        result = device_dispatch->GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties);
+    }
+    record_obj.result = result;
+    {
+        VVL_ZoneScopedN("PostCallRecord");
+        for (auto& vo : device_dispatch->intercept_vectors[InterceptIdPostCallRecordGetMemoryMetalHandlePropertiesEXT]) {
+            auto lock = vo->WriteLock();
+            vo->PostCallRecordGetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties,
+                                                                record_obj);
+        }
+    }
+    return result;
+}
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
 VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice device,
                                                               const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
                                                               const VkAllocationCallbacks* pAllocator,
@@ -27436,6 +27520,10 @@ const vvl::unordered_map<std::string, function_data>& GetNameToFuncPtrMap() {
         {"vkUpdateIndirectExecutionSetShaderEXT", {kFuncTypeDev, (void*)UpdateIndirectExecutionSetShaderEXT}},
         {"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV",
          {kFuncTypePdev, (void*)GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV}},
+#ifdef VK_USE_PLATFORM_METAL_EXT
+        {"vkGetMemoryMetalHandleEXT", {kFuncTypeDev, (void*)GetMemoryMetalHandleEXT}},
+        {"vkGetMemoryMetalHandlePropertiesEXT", {kFuncTypeDev, (void*)GetMemoryMetalHandlePropertiesEXT}},
+#endif  // VK_USE_PLATFORM_METAL_EXT
         {"vkCreateAccelerationStructureKHR", {kFuncTypeDev, (void*)CreateAccelerationStructureKHR}},
         {"vkDestroyAccelerationStructureKHR", {kFuncTypeDev, (void*)DestroyAccelerationStructureKHR}},
         {"vkCmdBuildAccelerationStructuresKHR", {kFuncTypeDev, (void*)CmdBuildAccelerationStructuresKHR}},

layers/vulkan/generated/device_features.cpp

@@ -726,6 +726,12 @@ void GetEnabledDeviceFeatures(const VkDeviceCreateInfo *pCreateInfo, DeviceFeatu
                 features->maintenance8 |= enabled->maintenance8 == VK_TRUE;
                 break;
             }
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: {
+                const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *enabled =
+                    reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(pNext);
+                features->videoMaintenance2 |= enabled->videoMaintenance2 == VK_TRUE;
+                break;
+            }
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: {
                 const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *enabled =
                     reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(pNext);

layers/vulkan/generated/device_features.h

@@ -890,6 +890,8 @@ struct DeviceFeatures {
     bool videoEncodeQuantizationMap;
     // VkPhysicalDeviceVideoMaintenance1FeaturesKHR
     bool videoMaintenance1;
+    // VkPhysicalDeviceVideoMaintenance2FeaturesKHR
+    bool videoMaintenance2;
     // VkPhysicalDeviceVulkan12Features
     bool descriptorIndexing;
     // VkPhysicalDeviceVulkan12Features

layers/vulkan/generated/dispatch_functions.h

@@ -4202,6 +4202,21 @@ static inline VkResult DispatchGetPhysicalDeviceCooperativeMatrixFlexibleDimensi
     auto dispatch = vvl::dispatch::GetData(physicalDevice);
     return dispatch->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice, pPropertyCount, pProperties);
 }
+#ifdef VK_USE_PLATFORM_METAL_EXT
+
+static inline VkResult DispatchGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
+                                                       void** pHandle) {
+    auto dispatch = vvl::dispatch::GetData(device);
+    return dispatch->GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle);
+}
+
+static inline VkResult DispatchGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+                                                                 const void* pHandle,
+                                                                 VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) {
+    auto dispatch = vvl::dispatch::GetData(device);
+    return dispatch->GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties);
+}
+#endif  // VK_USE_PLATFORM_METAL_EXT
 
 static inline VkResult DispatchCreateAccelerationStructureKHR(VkDevice device,
                                                               const VkAccelerationStructureCreateInfoKHR* pCreateInfo,

layers/vulkan/generated/dispatch_object.cpp

@@ -8249,6 +8249,38 @@ VkResult Instance::GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertie
 
     return result;
 }
+#ifdef VK_USE_PLATFORM_METAL_EXT
+
+VkResult Device::GetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
+                                         void** pHandle) {
+    if (!wrap_handles) return device_dispatch_table.GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle);
+    vku::safe_VkMemoryGetMetalHandleInfoEXT var_local_pGetMetalHandleInfo;
+    vku::safe_VkMemoryGetMetalHandleInfoEXT* local_pGetMetalHandleInfo = nullptr;
+    {
+        if (pGetMetalHandleInfo) {
+            local_pGetMetalHandleInfo = &var_local_pGetMetalHandleInfo;
+            local_pGetMetalHandleInfo->initialize(pGetMetalHandleInfo);
+
+            if (pGetMetalHandleInfo->memory) {
+                local_pGetMetalHandleInfo->memory = Unwrap(pGetMetalHandleInfo->memory);
+            }
+        }
+    }
+    VkResult result = device_dispatch_table.GetMemoryMetalHandleEXT(
+        device, (const VkMemoryGetMetalHandleInfoEXT*)local_pGetMetalHandleInfo, pHandle);
+
+    return result;
+}
+
+VkResult Device::GetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+                                                   const void* pHandle,
+                                                   VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) {
+    VkResult result =
+        device_dispatch_table.GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties);
+
+    return result;
+}
+#endif  // VK_USE_PLATFORM_METAL_EXT
 
 VkResult Device::CreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
                                                 const VkAllocationCallbacks* pAllocator,

layers/vulkan/generated/dispatch_object_device_methods.h

@@ -924,6 +924,11 @@ void UpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionS
 void UpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet,
                                          uint32_t executionSetWriteCount,
                                          const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites);
+#ifdef VK_USE_PLATFORM_METAL_EXT
+VkResult GetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle);
+VkResult GetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle,
+                                           VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
+#endif  // VK_USE_PLATFORM_METAL_EXT
 VkResult CreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
                                         const VkAllocationCallbacks* pAllocator,
                                         VkAccelerationStructureKHR* pAccelerationStructure);

layers/vulkan/generated/dispatch_vector.cpp

@@ -1820,6 +1820,14 @@ void Device::InitObjectDispatchVectors() {
     BUILD_DISPATCH_VECTOR(PreCallValidateUpdateIndirectExecutionSetShaderEXT);
     BUILD_DISPATCH_VECTOR(PreCallRecordUpdateIndirectExecutionSetShaderEXT);
     BUILD_DISPATCH_VECTOR(PostCallRecordUpdateIndirectExecutionSetShaderEXT);
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    BUILD_DISPATCH_VECTOR(PreCallValidateGetMemoryMetalHandleEXT);
+    BUILD_DISPATCH_VECTOR(PreCallRecordGetMemoryMetalHandleEXT);
+    BUILD_DISPATCH_VECTOR(PostCallRecordGetMemoryMetalHandleEXT);
+    BUILD_DISPATCH_VECTOR(PreCallValidateGetMemoryMetalHandlePropertiesEXT);
+    BUILD_DISPATCH_VECTOR(PreCallRecordGetMemoryMetalHandlePropertiesEXT);
+    BUILD_DISPATCH_VECTOR(PostCallRecordGetMemoryMetalHandlePropertiesEXT);
+#endif  // VK_USE_PLATFORM_METAL_EXT
     BUILD_DISPATCH_VECTOR(PreCallValidateCreateAccelerationStructureKHR);
     BUILD_DISPATCH_VECTOR(PreCallRecordCreateAccelerationStructureKHR);
     BUILD_DISPATCH_VECTOR(PostCallRecordCreateAccelerationStructureKHR);

layers/vulkan/generated/dispatch_vector.h

@@ -1742,6 +1742,12 @@ typedef enum InterceptId {
     InterceptIdPreCallValidateUpdateIndirectExecutionSetShaderEXT,
     InterceptIdPreCallRecordUpdateIndirectExecutionSetShaderEXT,
     InterceptIdPostCallRecordUpdateIndirectExecutionSetShaderEXT,
+    InterceptIdPreCallValidateGetMemoryMetalHandleEXT,
+    InterceptIdPreCallRecordGetMemoryMetalHandleEXT,
+    InterceptIdPostCallRecordGetMemoryMetalHandleEXT,
+    InterceptIdPreCallValidateGetMemoryMetalHandlePropertiesEXT,
+    InterceptIdPreCallRecordGetMemoryMetalHandlePropertiesEXT,
+    InterceptIdPostCallRecordGetMemoryMetalHandlePropertiesEXT,
     InterceptIdPreCallValidateCreateAccelerationStructureKHR,
     InterceptIdPreCallRecordCreateAccelerationStructureKHR,
     InterceptIdPostCallRecordCreateAccelerationStructureKHR,