Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package vulkan-tools for openSUSE:Factory checked in at 2026-10-01 16:59:48 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/vulkan-tools (Old) and /work/SRC/openSUSE:Factory/.vulkan-tools.new.1253 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "vulkan-tools" Thu Oct 1 16:59:48 2026 rev:63 rq:1381541 version:1.4.363 Changes: -------- --- /work/SRC/openSUSE:Factory/vulkan-tools/vulkan-tools.changes 2026-08-03 17:15:15.942484332 +0200 +++ /work/SRC/openSUSE:Factory/.vulkan-tools.new.1253/vulkan-tools.changes 2026-10-01 16:59:53.611303256 +0200 @@ -1,0 +2,8 @@ +Mon Sep 28 23:10:17 UTC 2026 - Jan Engelhardt <[email protected]> + +- Update to tag SDK-1.4.363.0 + * vulkaninfo: Enable more instance extensions + * Add VK_EXT_display_surface_counter instance extension + * vulkaninfo: Include extended flags in video format props output + +------------------------------------------------------------------- Old: ---- vulkan-sdk-1.4.357.0.tar.gz New: ---- vulkan-sdk-1.4.363.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ vulkan-tools.spec ++++++ --- /var/tmp/diff_new_pack.1NfVaF/_old 2026-10-01 16:59:54.385335679 +0200 +++ /var/tmp/diff_new_pack.1NfVaF/_new 2026-10-01 16:59:54.389335847 +0200 @@ -17,7 +17,7 @@ Name: vulkan-tools -Version: 1.4.357 +Version: 1.4.363 Release: 0 Summary: Diagnostic utilities for Vulkan License: Apache-2.0 ++++++ _scmsync.obsinfo ++++++ --- /var/tmp/diff_new_pack.1NfVaF/_old 2026-10-01 16:59:54.427337439 +0200 +++ /var/tmp/diff_new_pack.1NfVaF/_new 2026-10-01 16:59:54.431337606 +0200 @@ -1,5 +1,5 @@ -mtime: 1785282493 -commit: c4682528f77d69bb13d14241b79e33f39a6ebe974bf3f4e50d593313a3d65ed7 +mtime: 1790637042 +commit: 20b60a7a578aae2d6fd8a57c9afb09cf35ac34cdcf95f3e687a27bea933bdc26 url: https://src.opensuse.org/jengelh/vulkan-tools revision: master ++++++ build.specials.obscpio ++++++ ++++++ build.specials.obscpio ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/.gitignore new/.gitignore --- old/.gitignore 1970-01-01 01:00:00.000000000 +0100 +++ new/.gitignore 2026-09-29 01:10:42.000000000 +0200 @@ -0,0 +1 @@ +.osc ++++++ vulkan-sdk-1.4.357.0.tar.gz -> vulkan-sdk-1.4.363.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/CMakeLists.txt new/Vulkan-Tools-vulkan-sdk-1.4.363.0/CMakeLists.txt --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/CMakeLists.txt 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/CMakeLists.txt 2026-09-18 06:00:48.000000000 +0200 @@ -18,7 +18,7 @@ cmake_minimum_required(VERSION 3.22.1) # The VERSION field is generated with the "--generated-version" flag in the generate_source.py script -project(Vulkan-Tools VERSION 1.4.357) +project(Vulkan-Tools VERSION 1.4.363) # This variable enables downstream users to customize the target API # variant (e.g. Vulkan SC) @@ -61,6 +61,11 @@ find_package(VulkanLoader QUIET REQUIRED CONFIG) endif() +# Workaround AppleClang using the wrong headers when there are headers in /usr/local/include +if (CMAKE_C_COMPILER_ID STREQUAL AppleClang AND TARGET Vulkan::Headers AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.25) + set_target_properties(Vulkan::Headers PROPERTIES SYSTEM OFF) +endif() + include(GNUInstallDirs) if (BUILD_WERROR) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/VkICD_mock_icd.json.in new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/VkICD_mock_icd.json.in --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/VkICD_mock_icd.json.in 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/VkICD_mock_icd.json.in 2026-09-18 06:00:48.000000000 +0200 @@ -2,6 +2,6 @@ "file_format_version": "1.0.1", "ICD": { "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.4.357" + "api_version": "1.4.363" } } \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/generated/function_declarations.h new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/generated/function_declarations.h --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/generated/function_declarations.h 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/generated/function_declarations.h 2026-09-18 06:00:48.000000000 +0200 @@ -241,6 +241,7 @@ {"VK_KHR_present_mode_fifo_latest_ready", VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION}, {"VK_KHR_opacity_micromap", VK_KHR_OPACITY_MICROMAP_SPEC_VERSION}, {"VK_KHR_maintenance10", VK_KHR_MAINTENANCE_10_SPEC_VERSION}, + {"VK_KHR_pipeline_library_group_handles", VK_KHR_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION}, {"VK_KHR_maintenance11", VK_KHR_MAINTENANCE_11_SPEC_VERSION}, {"VK_KHR_extended_flags", VK_KHR_EXTENDED_FLAGS_SPEC_VERSION}, {"VK_NV_glsl_shader", VK_NV_GLSL_SHADER_SPEC_VERSION}, @@ -566,13 +567,18 @@ {"VK_SEC_pipeline_cache_incremental_mode", VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION}, {"VK_EXT_shader_uniform_buffer_unsized_array", VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION}, {"VK_NV_compute_occupancy_priority", VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION}, + {"VK_EXT_cooperative_matrix_maintenance1", VK_EXT_COOPERATIVE_MATRIX_MAINTENANCE_1_SPEC_VERSION}, {"VK_EXT_shader_subgroup_partitioned", VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION}, {"VK_EXT_shader_ocp_microscaling_types", VK_EXT_SHADER_OCP_MICROSCALING_TYPES_SPEC_VERSION}, {"VK_VALVE_shader_mixed_float_dot_product", VK_VALVE_SHADER_MIXED_FLOAT_DOT_PRODUCT_SPEC_VERSION}, {"VK_SEC_throttle_hint", VK_SEC_THROTTLE_HINT_SPEC_VERSION}, {"VK_ARM_data_graph_neural_accelerator_statistics", VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_SPEC_VERSION}, {"VK_EXT_primitive_restart_index", VK_EXT_PRIMITIVE_RESTART_INDEX_SPEC_VERSION}, + {"VK_EXT_image_tiling_control", VK_EXT_IMAGE_TILING_CONTROL_SPEC_VERSION}, {"VK_NV_cooperative_matrix_decode_vector", VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_SPEC_VERSION}, + {"VK_NV_private_data_base_handle", VK_NV_PRIVATE_DATA_BASE_HANDLE_SPEC_VERSION}, + {"VK_INTEL_device_info", VK_INTEL_DEVICE_INFO_SPEC_VERSION}, + {"VK_VALVE_buffer_device_address_allocation_alignment", VK_VALVE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_SPEC_VERSION}, {"VK_KHR_acceleration_structure", VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION}, {"VK_KHR_ray_tracing_pipeline", VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION}, {"VK_KHR_ray_query", VK_KHR_RAY_QUERY_SPEC_VERSION}, @@ -3139,6 +3145,10 @@ static VKAPI_ATTR void VKAPI_CALL CmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixProperties2EXT( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo, + uint32_t* pPropertyCount, VkCooperativeMatrixProperties2EXT* pProperties); #ifdef VK_USE_PLATFORM_UBM_SEC static VKAPI_ATTR VkResult VKAPI_CALL CreateUbmSurfaceSEC(VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo, @@ -4200,6 +4210,7 @@ {"vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM", (void*)GetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM}, {"vkCmdSetComputeOccupancyPriorityNV", (void*)CmdSetComputeOccupancyPriorityNV}, + {"vkGetPhysicalDeviceCooperativeMatrixProperties2EXT", (void*)GetPhysicalDeviceCooperativeMatrixProperties2EXT}, #ifdef VK_USE_PLATFORM_UBM_SEC {"vkCreateUbmSurfaceSEC", (void*)CreateUbmSurfaceSEC}, #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/generated/function_definitions.h new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/generated/function_definitions.h --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/generated/function_definitions.h 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/generated/function_definitions.h 2026-09-18 06:00:48.000000000 +0200 @@ -4719,6 +4719,12 @@ const VkComputeOccupancyPriorityParametersNV* pParameters) { // Not a CREATE or DESTROY function } +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixProperties2EXT( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceCooperativeMatrixInfo2EXT* pCooperativeMatrixInfo, + uint32_t* pPropertyCount, VkCooperativeMatrixProperties2EXT* pProperties) { + // Not a CREATE or DESTROY function + return VK_SUCCESS; +} #ifdef VK_USE_PLATFORM_UBM_SEC static VKAPI_ATTR VkResult VKAPI_CALL CreateUbmSurfaceSEC(VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/generated/vk_typemap_helper.h new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/generated/vk_typemap_helper.h --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/icd/generated/vk_typemap_helper.h 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/icd/generated/vk_typemap_helper.h 2026-09-18 06:00:48.000000000 +0200 @@ -6188,6 +6188,18 @@ typedef VkResolveImageModeInfoKHR Type; }; +// Map type VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_KHR +template <> +struct LvlTypeMap<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_KHR; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_KHR> { + typedef VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR Type; +}; + // Map type VkPhysicalDeviceMaintenance11FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR template <> struct LvlTypeMap<VkPhysicalDeviceMaintenance11FeaturesKHR> { @@ -11998,18 +12010,6 @@ typedef VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM Type; }; -// Map type VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT to id -// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT -template <> -struct LvlTypeMap<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> { - static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; -}; - -template <> -struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT> { - typedef VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT Type; -}; - // Map type VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT to id // VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT template <> @@ -13847,6 +13847,40 @@ typedef VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV Type; }; +// Map type VkCooperativeMatrixProperties2EXT to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_2_EXT +template <> +struct LvlTypeMap<VkCooperativeMatrixProperties2EXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_2_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_2_EXT> { + typedef VkCooperativeMatrixProperties2EXT Type; +}; + +// Map type VkPhysicalDeviceCooperativeMatrixInfo2EXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_INFO_2_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixInfo2EXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_INFO_2_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_INFO_2_EXT> { + typedef VkPhysicalDeviceCooperativeMatrixInfo2EXT Type; +}; + +// Map type VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT> { + typedef VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT Type; +}; + // Map type VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT to id // VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT template <> @@ -13966,6 +14000,28 @@ typedef VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT Type; }; +// Map type VkPhysicalDeviceImageTilingControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT +template <> +struct LvlTypeMap<VkPhysicalDeviceImageTilingControlFeaturesEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT> { + typedef VkPhysicalDeviceImageTilingControlFeaturesEXT Type; +}; + +// Map type VkImageTilingControlCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT +template <> +struct LvlTypeMap<VkImageTilingControlCreateInfoEXT> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT> { + typedef VkImageTilingControlCreateInfoEXT Type; +}; + // Map type VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV to id // VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV template <> @@ -13978,6 +14034,67 @@ typedef VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV Type; }; +// Map type VkPhysicalDevicePrivateDataBaseHandleFeaturesNV to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV +template <> +struct LvlTypeMap<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV> { + typedef VkPhysicalDevicePrivateDataBaseHandleFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceInfoPropertiesINTEL to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INFO_PROPERTIES_INTEL +template <> +struct LvlTypeMap<VkPhysicalDeviceInfoPropertiesINTEL> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INFO_PROPERTIES_INTEL; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INFO_PROPERTIES_INTEL> { + typedef VkPhysicalDeviceInfoPropertiesINTEL Type; +}; + +// Map type VkPhysicalDeviceBufferDeviceAddressAllocationAlignmentFeaturesVALVE to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_FEATURES_VALVE +template <> +struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressAllocationAlignmentFeaturesVALVE> { + static const VkStructureType kSType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_FEATURES_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_FEATURES_VALVE> { + typedef VkPhysicalDeviceBufferDeviceAddressAllocationAlignmentFeaturesVALVE Type; +}; + +// Map type VkPhysicalDeviceBufferDeviceAddressAllocationAlignmentPropertiesVALVE to id +// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_PROPERTIES_VALVE +template <> +struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressAllocationAlignmentPropertiesVALVE> { + static const VkStructureType kSType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_PROPERTIES_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_ALLOCATION_ALIGNMENT_PROPERTIES_VALVE> { + typedef VkPhysicalDeviceBufferDeviceAddressAllocationAlignmentPropertiesVALVE Type; +}; + +// Map type VkBufferDeviceAddressAlignmentAllocateInfoVALVE to id +// VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_ALIGNMENT_ALLOCATE_INFO_VALVE +template <> +struct LvlTypeMap<VkBufferDeviceAddressAlignmentAllocateInfoVALVE> { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_ALIGNMENT_ALLOCATE_INFO_VALVE; +}; + +template <> +struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_ALIGNMENT_ALLOCATE_INFO_VALVE> { + typedef VkBufferDeviceAddressAlignmentAllocateInfoVALVE Type; +}; + // Map type VkAccelerationStructureGeometryTrianglesDataKHR to id // VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR template <> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/scripts/generators/vulkaninfo_generator.py new/Vulkan-Tools-vulkan-sdk-1.4.363.0/scripts/generators/vulkaninfo_generator.py --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/scripts/generators/vulkaninfo_generator.py 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/scripts/generators/vulkaninfo_generator.py 2026-09-18 06:00:48.000000000 +0200 @@ -460,6 +460,21 @@ result.push_back(std::move(profile)); } }; + + auto add_extended_flags = [&](void **ppnext, video_format_properties_chain* format_properties_chain) { + if (format_properties_chain != nullptr && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_EXTENDED_FLAGS_EXTENSION_NAME)) { + format_properties_chain->ImageCreateFlags2CreateInfoKHR.sType = + VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + *ppnext = &format_properties_chain->ImageCreateFlags2CreateInfoKHR; + ppnext = &format_properties_chain->ImageCreateFlags2CreateInfoKHR.pNext; + format_properties_chain->ImageUsageFlags2CreateInfoKHR.sType = + VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + *ppnext = &format_properties_chain->ImageUsageFlags2CreateInfoKHR; + ppnext = &format_properties_chain->ImageUsageFlags2CreateInfoKHR.pNext; + } + return ppnext; + }; ''') # Generate individual video profiles from the video codec metadata @@ -562,6 +577,7 @@ # Callback to create video format properties chain out.append(f'{" " * 28}[&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {{\n') out.append(f'{" " * 28} auto format_properties_chain = std::make_unique<video_format_properties_chain>();\n') + out.append(f'{" " * 28} ppnext = add_extended_flags(ppnext, format_properties_chain.get());\n') for formatProps in format.properties: structDef = self.vk.structs[formatProps] out.append(self.AddGuardHeader(structDef)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/scripts/known_good.json new/Vulkan-Tools-vulkan-sdk-1.4.363.0/scripts/known_good.json --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/scripts/known_good.json 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/scripts/known_good.json 2026-09-18 06:00:48.000000000 +0200 @@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.4.357" + "commit": "v1.4.363" }, { "name": "MoltenVK", @@ -15,7 +15,7 @@ "sub_dir": "MoltenVK", "build_dir": "MoltenVK", "install_dir": "MoltenVK", - "commit": "v1.4.1", + "commit": "v1.4.2", "custom_build": [ "./fetchDependencies --macos", "xcodebuild -project MoltenVKPackaging.xcodeproj GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS MVK_CONFIG_LOG_LEVEL=1' -scheme \"MoltenVK Package (macOS only)\" build" @@ -56,7 +56,7 @@ "cmake_options": [ "-DLOADER_USE_UNSAFE_FILE_SEARCH=ON" ], - "commit": "v1.4.357", + "commit": "v1.4.363", "build_platforms": [ "windows", "linux", diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/vulkaninfo/generated/vulkaninfo.hpp new/Vulkan-Tools-vulkan-sdk-1.4.363.0/vulkaninfo/generated/vulkaninfo.hpp --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/vulkaninfo/generated/vulkaninfo.hpp 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/vulkaninfo/generated/vulkaninfo.hpp 2026-09-18 06:00:48.000000000 +0200 @@ -1196,6 +1196,8 @@ return "DRIVER_ID_MESA_GFXSTREAM"; case (VK_DRIVER_ID_APE_SOFT): return "DRIVER_ID_APE_SOFT"; + case (VK_DRIVER_ID_RESERVED_31): + return "DRIVER_ID_RESERVED_31"; default: return std::string("UNKNOWN_VkDriverId_value") + std::to_string(value); } @@ -4771,6 +4773,8 @@ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj); void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceCooperativeMatrixFeaturesKHR &obj); +void DumpVkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT( + Printer &p, std::string name, const VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &obj); void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR &obj); void DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(Printer &p, std::string name, @@ -4890,6 +4894,8 @@ void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer &p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures &obj); void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &obj); +void DumpVkPhysicalDeviceImageTilingControlFeaturesEXT(Printer &p, std::string name, + const VkPhysicalDeviceImageTilingControlFeaturesEXT &obj); void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImageViewMinLodFeaturesEXT &obj); void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name, @@ -4988,8 +4994,8 @@ const VkPhysicalDevicePipelineCreationCacheControlFeatures &obj); void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR( Printer &p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj); -void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer &p, std::string name, - const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &obj); +void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR(Printer &p, std::string name, + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR &obj); void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePipelinePropertiesFeaturesEXT &obj); void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer &p, std::string name, @@ -5586,6 +5592,16 @@ p.PrintKeyBool("cooperativeMatrix", static_cast<bool>(obj.cooperativeMatrix)); p.PrintKeyBool("cooperativeMatrixRobustBufferAccess", static_cast<bool>(obj.cooperativeMatrixRobustBufferAccess)); } +void DumpVkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT( + Printer &p, std::string name, const VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(37); + p.PrintKeyBool("cooperativeMatrixProperties2", static_cast<bool>(obj.cooperativeMatrixProperties2)); + p.PrintKeyBool("cooperativeMatrixReductions", static_cast<bool>(obj.cooperativeMatrixReductions)); + p.PrintKeyBool("cooperativeMatrixConversions", static_cast<bool>(obj.cooperativeMatrixConversions)); + p.PrintKeyBool("cooperativeMatrixPerElementOperations", static_cast<bool>(obj.cooperativeMatrixPerElementOperations)); + p.PrintKeyBool("cooperativeMatrixGetCoordinate", static_cast<bool>(obj.cooperativeMatrixGetCoordinate)); +} void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR &obj) { ObjectWrapper object{p, name}; @@ -6294,6 +6310,12 @@ p.SetMinKeyWidth(19); p.PrintKeyBool("imageSlicedViewOf3D", static_cast<bool>(obj.imageSlicedViewOf3D)); } +void DumpVkPhysicalDeviceImageTilingControlFeaturesEXT(Printer &p, std::string name, + const VkPhysicalDeviceImageTilingControlFeaturesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(18); + p.PrintKeyBool("imageTilingControl", static_cast<bool>(obj.imageTilingControl)); +} void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceImageViewMinLodFeaturesEXT &obj) { ObjectWrapper object{p, name}; @@ -6897,8 +6919,8 @@ p.SetMinKeyWidth(22); p.PrintKeyBool("pipelineExecutableInfo", static_cast<bool>(obj.pipelineExecutableInfo)); } -void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer &p, std::string name, - const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &obj) { +void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR(Printer &p, std::string name, + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR &obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(27); p.PrintKeyBool("pipelineLibraryGroupHandles", static_cast<bool>(obj.pipelineLibraryGroupHandles)); @@ -9693,6 +9715,7 @@ VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR PhysicalDeviceComputeShaderDerivativesFeaturesKHR{}; VkPhysicalDeviceConditionalRenderingFeaturesEXT PhysicalDeviceConditionalRenderingFeaturesEXT{}; VkPhysicalDeviceCooperativeMatrixFeaturesKHR PhysicalDeviceCooperativeMatrixFeaturesKHR{}; + VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT{}; VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR PhysicalDeviceCopyMemoryIndirectFeaturesKHR{}; VkPhysicalDeviceCustomBorderColorFeaturesEXT PhysicalDeviceCustomBorderColorFeaturesEXT{}; VkPhysicalDeviceCustomResolveFeaturesEXT PhysicalDeviceCustomResolveFeaturesEXT{}; @@ -9732,6 +9755,7 @@ VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT{}; VkPhysicalDeviceImageRobustnessFeatures PhysicalDeviceImageRobustnessFeatures{}; VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT PhysicalDeviceImageSlicedViewOf3DFeaturesEXT{}; + VkPhysicalDeviceImageTilingControlFeaturesEXT PhysicalDeviceImageTilingControlFeaturesEXT{}; VkPhysicalDeviceImageViewMinLodFeaturesEXT PhysicalDeviceImageViewMinLodFeaturesEXT{}; VkPhysicalDeviceImagelessFramebufferFeatures PhysicalDeviceImagelessFramebufferFeatures{}; VkPhysicalDeviceIndexTypeUint8Features PhysicalDeviceIndexTypeUint8Features{}; @@ -9766,7 +9790,7 @@ VkPhysicalDevicePipelineBinaryFeaturesKHR PhysicalDevicePipelineBinaryFeaturesKHR{}; VkPhysicalDevicePipelineCreationCacheControlFeatures PhysicalDevicePipelineCreationCacheControlFeatures{}; VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR{}; - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT{}; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR PhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR{}; VkPhysicalDevicePipelinePropertiesFeaturesEXT PhysicalDevicePipelinePropertiesFeaturesEXT{}; VkPhysicalDevicePipelineProtectedAccessFeatures PhysicalDevicePipelineProtectedAccessFeatures{}; VkPhysicalDevicePipelineRobustnessFeatures PhysicalDevicePipelineRobustnessFeatures{}; @@ -9885,6 +9909,8 @@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; PhysicalDeviceConditionalRenderingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; PhysicalDeviceCooperativeMatrixFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT; PhysicalDeviceCopyMemoryIndirectFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR; PhysicalDeviceCustomBorderColorFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; PhysicalDeviceCustomResolveFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT; @@ -9936,6 +9962,7 @@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; PhysicalDeviceImageRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; PhysicalDeviceImageSlicedViewOf3DFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; + PhysicalDeviceImageTilingControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT; PhysicalDeviceImageViewMinLodFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; PhysicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; PhysicalDeviceIndexTypeUint8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; @@ -9978,8 +10005,8 @@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; PhysicalDevicePipelineExecutablePropertiesFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; - PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType = - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + PhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR.sType = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_KHR; PhysicalDevicePipelinePropertiesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; PhysicalDevicePipelineProtectedAccessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; PhysicalDevicePipelineRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; @@ -10148,6 +10175,9 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceConditionalRenderingFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCooperativeMatrixFeaturesKHR)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_COOPERATIVE_MATRIX_MAINTENANCE_1_EXTENSION_NAME)) + chain_members.push_back( + reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCopyMemoryIndirectFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME)) @@ -10239,6 +10269,8 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageRobustnessFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageSlicedViewOf3DFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_TILING_CONTROL_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageTilingControlFeaturesEXT)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageViewMinLodFeaturesEXT)); if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) && @@ -10322,8 +10354,9 @@ chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineCreationCacheControlFeatures)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineExecutablePropertiesFeaturesKHR)); - if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME)) - chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT)); + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME) || + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME)) + chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR)); if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME)) chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelinePropertiesFeaturesEXT)); if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) && @@ -10712,6 +10745,13 @@ DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(p, name, *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_MAINTENANCE_1_FEATURES_EXT) { + const VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT *props = + (const VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT *)structure; + const char *name = "VkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT"; + DumpVkPhysicalDeviceCooperativeMatrixMaintenance1FeaturesEXT(p, name, *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR) { const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *props = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *)structure; @@ -11057,6 +11097,13 @@ DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(p, name, *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT) { + const VkPhysicalDeviceImageTilingControlFeaturesEXT *props = + (const VkPhysicalDeviceImageTilingControlFeaturesEXT *)structure; + const char *name = "VkPhysicalDeviceImageTilingControlFeaturesEXT"; + DumpVkPhysicalDeviceImageTilingControlFeaturesEXT(p, name, *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT) { const VkPhysicalDeviceImageViewMinLodFeaturesEXT *props = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)structure; const char *name = "VkPhysicalDeviceImageViewMinLodFeaturesEXT"; @@ -11373,11 +11420,20 @@ DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(p, name, *props); p.AddNewline(); } - if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT) { - const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *props = - (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)structure; - const char *name = "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"; - DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(p, name, *props); + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_KHR) { + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR *props = + (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR *)structure; + const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME) + ? "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR" + : ("VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"); + DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR(p, name, *props); + if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT") != 0 && + gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME)) { + p.AddNewline(); + p.SetSubHeader(); + DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesKHR( + p, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT", *props); + } p.AddNewline(); } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT) { @@ -13140,6 +13196,18 @@ } }; + auto add_extended_flags = [&](void **ppnext, video_format_properties_chain *format_properties_chain) { + if (format_properties_chain != nullptr && gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_EXTENDED_FLAGS_EXTENSION_NAME)) { + format_properties_chain->ImageCreateFlags2CreateInfoKHR.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + *ppnext = &format_properties_chain->ImageCreateFlags2CreateInfoKHR; + ppnext = &format_properties_chain->ImageCreateFlags2CreateInfoKHR.pNext; + format_properties_chain->ImageUsageFlags2CreateInfoKHR.sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + *ppnext = &format_properties_chain->ImageUsageFlags2CreateInfoKHR; + ppnext = &format_properties_chain->ImageUsageFlags2CreateInfoKHR.pNext; + } + return ppnext; + }; + if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) { const std::string codec_name = "H.264 Decode"; @@ -13205,6 +13273,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13217,6 +13286,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13426,6 +13496,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13438,6 +13509,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13538,6 +13610,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13550,6 +13623,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13641,6 +13715,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13653,6 +13728,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13811,6 +13887,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13823,6 +13900,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -13848,6 +13926,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); if (format_properties_chain != nullptr) { if (gpu.CheckPhysicalDeviceExtensionIncluded( VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { @@ -13882,6 +13961,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); if (format_properties_chain != nullptr) { if (gpu.CheckPhysicalDeviceExtensionIncluded( VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { @@ -14042,6 +14122,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -14054,6 +14135,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -14079,6 +14161,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); if (format_properties_chain != nullptr) { if (gpu.CheckPhysicalDeviceExtensionIncluded( VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { @@ -14123,6 +14206,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); if (format_properties_chain != nullptr) { if (gpu.CheckPhysicalDeviceExtensionIncluded( VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { @@ -14279,6 +14363,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -14291,6 +14376,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); return format_properties_chain; }, }, @@ -14316,6 +14402,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); if (format_properties_chain != nullptr) { if (gpu.CheckPhysicalDeviceExtensionIncluded( VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { @@ -14360,6 +14447,7 @@ }, [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> { auto format_properties_chain = std::make_unique<video_format_properties_chain>(); + ppnext = add_extended_flags(ppnext, format_properties_chain.get()); if (format_properties_chain != nullptr) { if (gpu.CheckPhysicalDeviceExtensionIncluded( VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/vulkaninfo/vulkaninfo.cpp new/Vulkan-Tools-vulkan-sdk-1.4.363.0/vulkaninfo/vulkaninfo.cpp --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/vulkaninfo/vulkaninfo.cpp 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/vulkaninfo/vulkaninfo.cpp 2026-09-18 06:00:48.000000000 +0200 @@ -28,6 +28,7 @@ * */ +#include <ctime> #include <string> #ifdef _WIN32 #include <crtdbg.h> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vulkan-Tools-vulkan-sdk-1.4.357.0/vulkaninfo/vulkaninfo.h new/Vulkan-Tools-vulkan-sdk-1.4.363.0/vulkaninfo/vulkaninfo.h --- old/Vulkan-Tools-vulkan-sdk-1.4.357.0/vulkaninfo/vulkaninfo.h 2026-07-20 16:44:12.000000000 +0200 +++ new/Vulkan-Tools-vulkan-sdk-1.4.363.0/vulkaninfo/vulkaninfo.h 2026-09-18 06:00:48.000000000 +0200 @@ -363,13 +363,15 @@ using CreateCapabilitiesChainCb = std::function<std::unique_ptr<video_capabilities_chain>(void **)>; struct CreateFormatPropertiesChainCb { std::string format_name; - VkImageUsageFlags image_usage_flags; + VkImageUsageFlags2KHR image_usage_flags; std::function<bool(const VkVideoCapabilitiesKHR &capabilities)> check_required_caps; std::function<std::unique_ptr<video_format_properties_chain>(void **)> callback; }; using CreateFormatPropertiesChainCbList = std::vector<CreateFormatPropertiesChainCb>; using InitProfileCb = std::function<void(AppVideoProfile &)>; + bool IsImageUsageFlags2Supported(AppGpu &gpu) const; + AppVideoProfile(AppGpu &gpu, VkPhysicalDevice phys_device, const std::string &in_name, const VkVideoProfileInfoKHR &in_profile_info, CreateProfileInfoChainCb create_profile_info_chain, CreateCapabilitiesChainCb create_capabilities_chain, @@ -406,9 +408,24 @@ continue; } + VkImageUsageFlags2CreateInfoKHR image_usage_flags2_info = {VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR, + &profile_list}; VkPhysicalDeviceVideoFormatInfoKHR video_format_info = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, - &profile_list, - create_format_properties_chain_info.image_usage_flags}; + &profile_list}; + + if (create_format_properties_chain_info.image_usage_flags <= VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM) { + // Regular 32-bit VkImageUsageFlags is sufficient + video_format_info.imageUsage = + static_cast<VkImageUsageFlags>(create_format_properties_chain_info.image_usage_flags); + } else { + if (!IsImageUsageFlags2Supported(gpu)) { + // This format uses one of the 64-bit flag bits therefore requires VkImageUsageFlags2KHR + continue; + } + // Include VkImageUsageFlags2CreateInfoKHR in the input chain + image_usage_flags2_info.usage = create_format_properties_chain_info.image_usage_flags; + video_format_info.pNext = &image_usage_flags2_info; + } uint32_t video_format_property_count = 0; result = @@ -662,6 +679,9 @@ if (strcmp(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); } + if (strcmp(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, ext.extensionName) == 0) { + inst_extensions.push_back(ext.extensionName); + } if (strcmp(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); } @@ -671,6 +691,9 @@ if (strcmp(VK_KHR_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); } + if (strcmp(VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME, ext.extensionName) == 0) { + inst_extensions.push_back(ext.extensionName); + } #ifdef VK_USE_PLATFORM_ANDROID_KHR if (strcmp(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); @@ -740,6 +763,12 @@ if (strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); } + if (strcmp(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, ext.extensionName) == 0) { + inst_extensions.push_back(ext.extensionName); + } + if (strcmp(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, ext.extensionName) == 0) { + inst_extensions.push_back(ext.extensionName); + } #endif if (strcmp(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); @@ -756,6 +785,9 @@ if (strcmp(VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME, ext.extensionName) == 0) { inst_extensions.push_back(ext.extensionName); } + if (strcmp(VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, ext.extensionName) == 0) { + inst_extensions.push_back(ext.extensionName); + } } } @@ -2044,6 +2076,11 @@ } }; +bool AppVideoProfile::IsImageUsageFlags2Supported(AppGpu &gpu) const { + // VkImageUsageFlags2KHR requires VK_KHR_extended_flags + return gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_EXTENDED_FLAGS_EXTENSION_NAME); +} + std::vector<VkPhysicalDeviceToolPropertiesEXT> GetToolingInfo(AppGpu &gpu) { if (vkGetPhysicalDeviceToolPropertiesEXT == nullptr) return {}; return GetVector<VkPhysicalDeviceToolPropertiesEXT>("vkGetPhysicalDeviceToolPropertiesEXT",
