Merge remote-tracking branch 'upstream/main'

- Test for a CMake-documented variable for the entire stack
- Remove complicated compiler testing
- Always require C++23, even in the interface
- Install the module interface file as part of the module target

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# ~~~
+# Copyright 2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+# ~~~
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 3

.reuse/dep5

@@ -2,18 +2,14 @@ Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-Name: Vulkan-Headers
 Source: https://github.com/KhronosGroup/Vulkan-Headers
 
-Files: registry/profiles/VP_KHR_roadmap_2022.json
-Copyright: 2022-2023 The Khronos Group Inc.
+Files: registry/profiles/VP_KHR_roadmap.json
+Copyright: 2022-2024 The Khronos Group Inc.
 License: Apache-2.0
 
 Files: registry/validusage.json
-Copyright: 2018-2023 The Khronos Group Inc.
+Copyright: 2018-2024 The Khronos Group Inc.
 License: Apache-2.0
 
 Files: .github/ISSUE_TEMPLATE/bug_report.md .github/pull_request_template.md
-Copyright: 2022-2023 The Khronos Group Inc.
-License: Apache-2.0
-
-Files: BUILD.md CODE_OF_CONDUCT.md CONTRIBUTING.md INTEGRATION.md README.md
-Copyright: 2018-2023 The Khronos Group Inc.
+Copyright: 2022-2024 The Khronos Group Inc.
 License: Apache-2.0

Makefile.release

@@ -0,0 +1,141 @@
+# Copyright 2024-2025 The Khronos Group Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Makefile.release - update external files generated in Vulkan spec
+# repository when a public specification update is done.
+
+# Needed to get the right version of test, apparently
+SHELL  = /bin/bash
+
+REVISION = 999
+
+# Location of other repository clones
+GIT	 = ..
+SPEC	 = $(GIT)/Vulkan-Docs
+# As of 1.4.322 spec update, the build process has been changed to use a
+# Vulkan-Hpp located underneath Vulkan-Docs (not a submodule).
+# If you are using one located elsewhere then override HPP.
+HPP	 = $(SPEC)/Vulkan-Hpp
+REGISTRY = $(GIT)/registry/vulkan
+
+update: revision-check create-branch update-files push-branch
+
+# Working branch for the update, and a test if it exists
+BRANCH = update-$(REVISION)
+
+# Switch to new branch which will contain the update
+create-branch: revision-check
+	git switch -q main
+	git pull -q
+	# If branch already exists, do nothing
+	@if test `git branch -l $(BRANCH) | wc -l` == 1 ; then \
+	    echo "Branch $(BRANCH) already exists" ; \
+	    git switch $(BRANCH) ; \
+	else \
+	    echo "Creating branch $(BRANCH)" ; \
+	    git switch -c $(BRANCH) ; \
+	fi
+
+# Update headers and scripts in the new branch
+update-files: remove-files update-headers update-scripts
+
+# To ensure updates are caught, old versions of installed files are
+# removed.
+# Files in include/ to keep
+HEADERS_KEEP = \
+    include/vulkan/vk_icd.h \
+    include/vulkan/vk_layer.h
+
+remove-files:
+	rm -rf $(filter-out $(HEADERS_KEEP), $(wildcard include/vulkan/*))
+	rm -rf include/vk_video
+	rm -rf registry
+	mkdir include/vk_video registry registry/profiles registry/spec_tools
+
+# Vulkan SC Vulkan-Hpp headers not published in the Vulkan-Headers repository
+SCHPPFILES = \
+    include/vulkan/vulkansc.hpp \
+    include/vulkan/vulkansc.cppm \
+    include/vulkan/vulkansc_*.hpp
+
+update-headers:
+	if test ! -d $(SPEC)/gen/include/ ; then \
+	    echo "No C header file source directory $(SPEC)/gen/include" ; \
+	    exit 1 ; \
+	fi
+	if test ! -d $(HPP)/vulkan ; then \
+	    echo "No C++ header file source directory $(HPP)/vulkan" ; \
+	    exit 1 ; \
+	fi
+	cp -r $(SPEC)/gen/include/* include/
+	cp -r $(HPP)/vulkan/* include/vulkan/
+	rm -f $(SCHPPFILES)
+
+# Top-level scripts / XML to install
+SCRIPTS = \
+    $(SPEC)/scripts/base_generator.py \
+    $(SPEC)/scripts/cgenerator.py \
+    $(SPEC)/scripts/generator.py \
+    $(SPEC)/scripts/parse_dependency.py \
+    $(SPEC)/scripts/reg.py \
+    $(SPEC)/scripts/stripAPI.py \
+    $(SPEC)/scripts/apiconventions.py \
+    $(SPEC)/scripts/vkconventions.py \
+    $(SPEC)/scripts/vulkan_object.py \
+    $(SPEC)/xml/vk.xml \
+    $(SPEC)/xml/video.xml \
+    $(REGISTRY)/specs/latest/validation/validusage.json
+
+# Scripts in registry/spec_tools to install
+SCRIPT_TOOLS = \
+    $(SPEC)/scripts/spec_tools/conventions.py \
+    $(SPEC)/scripts/spec_tools/util.py
+
+# Profiles to install
+PROFILES = \
+    $(wildcard $(SPEC)/xml/profiles/*)
+
+update-scripts:
+	cp $(SCRIPTS) registry/
+	cp $(PROFILES) registry/profiles/
+	cp $(SCRIPT_TOOLS) registry/spec_tools/
+
+# Once the branch is updated, push it to upstream and create an MR
+# This should be used cautiously after verifying the branch contents are
+# indeed correct and updates.
+#
+# Ideally we could automatically create the github PR.
+# This will require additional software, see e.g.
+#   https://medium.com/@ravipatel.it/creating-a-git-pull-request-using-the-command-line-a-detailed-guide-4ef1ea017fe2
+#   https://gist.github.com/devinschumacher/bc66c162d9c6c167952f1943d0e6419c
+# Gitlab supports this via 'git push' options e.g.
+#   -o merge_request.create -o merge_request.target=main -o merge_request.remove_source_branch \
+#   -o merge_request.title="Update for Vulkan-Docs 1.4.$(REVISION)" \
+#   -o merge_request.assign=oddhack
+# But for github we must manually create a PR after pushing
+push-branch: revision-check
+	git switch $(BRANCH)
+	git add -u
+	echo "Detect new files and add them. This may not always succeed."
+	echo "Adding new files:" `git diff --name-only main`
+	git add `git diff --name-only main`
+	git commit -m "Update for Vulkan-Docs 1.4.$(REVISION)"
+	git push --set-upstream origin $(BRANCH)
+	git switch main
+	git branch -d $(BRANCH)
+	echo "Now create a pull request by going to the URL:"
+	echo "  https://github.com/KhronosGroup/Vulkan-Headers/pull/new/$(BRANCH)"
+	echo "After accepting this PR, continue with:"
+	echo "    cd $(shell pwd) && make -f Makefile.release REVISION=$(REVISION) tag-branch"
+
+# Tag main for the update after accepting the update PR
+TAG = v1.4.$(REVISION)
+tag-branch:
+	git switch main
+	git pull
+	git tag -a $(TAG) -m "Update for Vulkan-Docs 1.4.$(REVISION)"
+	git push origin $(TAG)
+	echo "Now continue with Step 12 of the process (update public registry) from the wiki, until more scripting is done"
+
+revision-check:
+	@if test $(REVISION) = 999 ; then echo "Must specify explicit REVISION= in make invocation" ; exit 1 ; fi

SECURITY.md

@@ -0,0 +1,11 @@
+<!--
+Copyright 2023 The Khronos Group Inc.
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Security Policy
+
+To report a security issue, please disclose it at [security advisory](https://github.com/KhronosGroup/Vulkan-Headers/security/advisories/new).
+
+This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure.

include/vk_video/vulkan_video_codec_av1std.h

@@ -0,0 +1,394 @@
+#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_
+#define VULKAN_VIDEO_CODEC_AV1STD_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 is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_av1std 1
+#include "vulkan_video_codecs_common.h"
+#define STD_VIDEO_AV1_NUM_REF_FRAMES      8U
+#define STD_VIDEO_AV1_REFS_PER_FRAME      7U
+#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8U
+#define STD_VIDEO_AV1_MAX_TILE_COLS       64U
+#define STD_VIDEO_AV1_MAX_TILE_ROWS       64U
+#define STD_VIDEO_AV1_MAX_SEGMENTS        8U
+#define STD_VIDEO_AV1_SEG_LVL_MAX         8U
+#define STD_VIDEO_AV1_PRIMARY_REF_NONE    7U
+#define STD_VIDEO_AV1_SELECT_INTEGER_MV   2U
+#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2U
+#define STD_VIDEO_AV1_SKIP_MODE_FRAMES    2U
+#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4U
+#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2U
+#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8U
+#define STD_VIDEO_AV1_MAX_NUM_PLANES      3U
+#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6U
+#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS    14U
+#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS   10U
+#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS   10U
+#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA    24U
+#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA  25U
+
+typedef enum StdVideoAV1Profile {
+    STD_VIDEO_AV1_PROFILE_MAIN = 0,
+    STD_VIDEO_AV1_PROFILE_HIGH = 1,
+    STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2,
+    STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1Profile;
+
+typedef enum StdVideoAV1Level {
+    STD_VIDEO_AV1_LEVEL_2_0 = 0,
+    STD_VIDEO_AV1_LEVEL_2_1 = 1,
+    STD_VIDEO_AV1_LEVEL_2_2 = 2,
+    STD_VIDEO_AV1_LEVEL_2_3 = 3,
+    STD_VIDEO_AV1_LEVEL_3_0 = 4,
+    STD_VIDEO_AV1_LEVEL_3_1 = 5,
+    STD_VIDEO_AV1_LEVEL_3_2 = 6,
+    STD_VIDEO_AV1_LEVEL_3_3 = 7,
+    STD_VIDEO_AV1_LEVEL_4_0 = 8,
+    STD_VIDEO_AV1_LEVEL_4_1 = 9,
+    STD_VIDEO_AV1_LEVEL_4_2 = 10,
+    STD_VIDEO_AV1_LEVEL_4_3 = 11,
+    STD_VIDEO_AV1_LEVEL_5_0 = 12,
+    STD_VIDEO_AV1_LEVEL_5_1 = 13,
+    STD_VIDEO_AV1_LEVEL_5_2 = 14,
+    STD_VIDEO_AV1_LEVEL_5_3 = 15,
+    STD_VIDEO_AV1_LEVEL_6_0 = 16,
+    STD_VIDEO_AV1_LEVEL_6_1 = 17,
+    STD_VIDEO_AV1_LEVEL_6_2 = 18,
+    STD_VIDEO_AV1_LEVEL_6_3 = 19,
+    STD_VIDEO_AV1_LEVEL_7_0 = 20,
+    STD_VIDEO_AV1_LEVEL_7_1 = 21,
+    STD_VIDEO_AV1_LEVEL_7_2 = 22,
+    STD_VIDEO_AV1_LEVEL_7_3 = 23,
+    STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1Level;
+
+typedef enum StdVideoAV1FrameType {
+    STD_VIDEO_AV1_FRAME_TYPE_KEY = 0,
+    STD_VIDEO_AV1_FRAME_TYPE_INTER = 1,
+    STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2,
+    STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3,
+    STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1FrameType;
+
+typedef enum StdVideoAV1ReferenceName {
+    STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0,
+    STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1,
+    STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2,
+    STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3,
+    STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4,
+    STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5,
+    STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6,
+    STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7,
+    STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1ReferenceName;
+
+typedef enum StdVideoAV1InterpolationFilter {
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1InterpolationFilter;
+
+typedef enum StdVideoAV1TxMode {
+    STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0,
+    STD_VIDEO_AV1_TX_MODE_LARGEST = 1,
+    STD_VIDEO_AV1_TX_MODE_SELECT = 2,
+    STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1TxMode;
+
+typedef enum StdVideoAV1FrameRestorationType {
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1FrameRestorationType;
+
+typedef enum StdVideoAV1ColorPrimaries {
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED = 2,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF,
+  // STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a legacy alias
+    STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
+    STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1ColorPrimaries;
+
+typedef enum StdVideoAV1TransferCharacteristics {
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1TransferCharacteristics;
+
+typedef enum StdVideoAV1MatrixCoefficients {
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1MatrixCoefficients;
+
+typedef enum StdVideoAV1ChromaSamplePosition {
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF
+} StdVideoAV1ChromaSamplePosition;
+typedef struct StdVideoAV1ColorConfigFlags {
+    uint32_t    mono_chrome : 1;
+    uint32_t    color_range : 1;
+    uint32_t    separate_uv_delta_q : 1;
+    uint32_t    color_description_present_flag : 1;
+    uint32_t    reserved : 28;
+} StdVideoAV1ColorConfigFlags;
+
+typedef struct StdVideoAV1ColorConfig {
+    StdVideoAV1ColorConfigFlags           flags;
+    uint8_t                               BitDepth;
+    uint8_t                               subsampling_x;
+    uint8_t                               subsampling_y;
+    uint8_t                               reserved1;
+    StdVideoAV1ColorPrimaries             color_primaries;
+    StdVideoAV1TransferCharacteristics    transfer_characteristics;
+    StdVideoAV1MatrixCoefficients         matrix_coefficients;
+    StdVideoAV1ChromaSamplePosition       chroma_sample_position;
+} StdVideoAV1ColorConfig;
+
+typedef struct StdVideoAV1TimingInfoFlags {
+    uint32_t    equal_picture_interval : 1;
+    uint32_t    reserved : 31;
+} StdVideoAV1TimingInfoFlags;
+
+typedef struct StdVideoAV1TimingInfo {
+    StdVideoAV1TimingInfoFlags    flags;
+    uint32_t                      num_units_in_display_tick;
+    uint32_t                      time_scale;
+    uint32_t                      num_ticks_per_picture_minus_1;
+} StdVideoAV1TimingInfo;
+
+typedef struct StdVideoAV1LoopFilterFlags {
+    uint32_t    loop_filter_delta_enabled : 1;
+    uint32_t    loop_filter_delta_update : 1;
+    uint32_t    reserved : 30;
+} StdVideoAV1LoopFilterFlags;
+
+typedef struct StdVideoAV1LoopFilter {
+    StdVideoAV1LoopFilterFlags    flags;
+    uint8_t                       loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS];
+    uint8_t                       loop_filter_sharpness;
+    uint8_t                       update_ref_delta;
+    int8_t                        loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME];
+    uint8_t                       update_mode_delta;
+    int8_t                        loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS];
+} StdVideoAV1LoopFilter;
+
+typedef struct StdVideoAV1QuantizationFlags {
+    uint32_t    using_qmatrix : 1;
+    uint32_t    diff_uv_delta : 1;
+    uint32_t    reserved : 30;
+} StdVideoAV1QuantizationFlags;
+
+typedef struct StdVideoAV1Quantization {
+    StdVideoAV1QuantizationFlags    flags;
+    uint8_t                         base_q_idx;
+    int8_t                          DeltaQYDc;
+    int8_t                          DeltaQUDc;
+    int8_t                          DeltaQUAc;
+    int8_t                          DeltaQVDc;
+    int8_t                          DeltaQVAc;
+    uint8_t                         qm_y;
+    uint8_t                         qm_u;
+    uint8_t                         qm_v;
+} StdVideoAV1Quantization;
+
+typedef struct StdVideoAV1Segmentation {
+    uint8_t    FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS];
+    int16_t    FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX];
+} StdVideoAV1Segmentation;
+
+typedef struct StdVideoAV1TileInfoFlags {
+    uint32_t    uniform_tile_spacing_flag : 1;
+    uint32_t    reserved : 31;
+} StdVideoAV1TileInfoFlags;
+
+typedef struct StdVideoAV1TileInfo {
+    StdVideoAV1TileInfoFlags    flags;
+    uint8_t                     TileCols;
+    uint8_t                     TileRows;
+    uint16_t                    context_update_tile_id;
+    uint8_t                     tile_size_bytes_minus_1;
+    uint8_t                     reserved1[7];
+    const uint16_t*             pMiColStarts;
+    const uint16_t*             pMiRowStarts;
+    const uint16_t*             pWidthInSbsMinus1;
+    const uint16_t*             pHeightInSbsMinus1;
+} StdVideoAV1TileInfo;
+
+typedef struct StdVideoAV1CDEF {
+    uint8_t    cdef_damping_minus_3;
+    uint8_t    cdef_bits;
+    uint8_t    cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+    uint8_t    cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+    uint8_t    cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+    uint8_t    cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS];
+} StdVideoAV1CDEF;
+
+typedef struct StdVideoAV1LoopRestoration {
+    StdVideoAV1FrameRestorationType    FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES];
+    uint16_t                           LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES];
+} StdVideoAV1LoopRestoration;
+
+typedef struct StdVideoAV1GlobalMotion {
+    uint8_t    GmType[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    int32_t    gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS];
+} StdVideoAV1GlobalMotion;
+
+typedef struct StdVideoAV1FilmGrainFlags {
+    uint32_t    chroma_scaling_from_luma : 1;
+    uint32_t    overlap_flag : 1;
+    uint32_t    clip_to_restricted_range : 1;
+    uint32_t    update_grain : 1;
+    uint32_t    reserved : 28;
+} StdVideoAV1FilmGrainFlags;
+
+typedef struct StdVideoAV1FilmGrain {
+    StdVideoAV1FilmGrainFlags    flags;
+    uint8_t                      grain_scaling_minus_8;
+    uint8_t                      ar_coeff_lag;
+    uint8_t                      ar_coeff_shift_minus_6;
+    uint8_t                      grain_scale_shift;
+    uint16_t                     grain_seed;
+    uint8_t                      film_grain_params_ref_idx;
+    uint8_t                      num_y_points;
+    uint8_t                      point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
+    uint8_t                      point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS];
+    uint8_t                      num_cb_points;
+    uint8_t                      point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
+    uint8_t                      point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS];
+    uint8_t                      num_cr_points;
+    uint8_t                      point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
+    uint8_t                      point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS];
+    int8_t                       ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA];
+    int8_t                       ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
+    int8_t                       ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA];
+    uint8_t                      cb_mult;
+    uint8_t                      cb_luma_mult;
+    uint16_t                     cb_offset;
+    uint8_t                      cr_mult;
+    uint8_t                      cr_luma_mult;
+    uint16_t                     cr_offset;
+} StdVideoAV1FilmGrain;
+
+typedef struct StdVideoAV1SequenceHeaderFlags {
+    uint32_t    still_picture : 1;
+    uint32_t    reduced_still_picture_header : 1;
+    uint32_t    use_128x128_superblock : 1;
+    uint32_t    enable_filter_intra : 1;
+    uint32_t    enable_intra_edge_filter : 1;
+    uint32_t    enable_interintra_compound : 1;
+    uint32_t    enable_masked_compound : 1;
+    uint32_t    enable_warped_motion : 1;
+    uint32_t    enable_dual_filter : 1;
+    uint32_t    enable_order_hint : 1;
+    uint32_t    enable_jnt_comp : 1;
+    uint32_t    enable_ref_frame_mvs : 1;
+    uint32_t    frame_id_numbers_present_flag : 1;
+    uint32_t    enable_superres : 1;
+    uint32_t    enable_cdef : 1;
+    uint32_t    enable_restoration : 1;
+    uint32_t    film_grain_params_present : 1;
+    uint32_t    timing_info_present_flag : 1;
+    uint32_t    initial_display_delay_present_flag : 1;
+    uint32_t    reserved : 13;
+} StdVideoAV1SequenceHeaderFlags;
+
+typedef struct StdVideoAV1SequenceHeader {
+    StdVideoAV1SequenceHeaderFlags    flags;
+    StdVideoAV1Profile                seq_profile;
+    uint8_t                           frame_width_bits_minus_1;
+    uint8_t                           frame_height_bits_minus_1;
+    uint16_t                          max_frame_width_minus_1;
+    uint16_t                          max_frame_height_minus_1;
+    uint8_t                           delta_frame_id_length_minus_2;
+    uint8_t                           additional_frame_id_length_minus_1;
+    uint8_t                           order_hint_bits_minus_1;
+    uint8_t                           seq_force_integer_mv;
+    uint8_t                           seq_force_screen_content_tools;
+    uint8_t                           reserved1[5];
+    const StdVideoAV1ColorConfig*     pColorConfig;
+    const StdVideoAV1TimingInfo*      pTimingInfo;
+} StdVideoAV1SequenceHeader;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/vk_video/vulkan_video_codec_av1std_decode.h

@@ -0,0 +1,109 @@
+#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_
+#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1
+
+/*
+** Copyright 2015-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_decode is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_av1std_decode 1
+#include "vulkan_video_codec_av1std.h"
+
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0
+#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode"
+typedef struct StdVideoDecodeAV1PictureInfoFlags {
+    uint32_t    error_resilient_mode : 1;
+    uint32_t    disable_cdf_update : 1;
+    uint32_t    use_superres : 1;
+    uint32_t    render_and_frame_size_different : 1;
+    uint32_t    allow_screen_content_tools : 1;
+    uint32_t    is_filter_switchable : 1;
+    uint32_t    force_integer_mv : 1;
+    uint32_t    frame_size_override_flag : 1;
+    uint32_t    buffer_removal_time_present_flag : 1;
+    uint32_t    allow_intrabc : 1;
+    uint32_t    frame_refs_short_signaling : 1;
+    uint32_t    allow_high_precision_mv : 1;
+    uint32_t    is_motion_mode_switchable : 1;
+    uint32_t    use_ref_frame_mvs : 1;
+    uint32_t    disable_frame_end_update_cdf : 1;
+    uint32_t    allow_warped_motion : 1;
+    uint32_t    reduced_tx_set : 1;
+    uint32_t    reference_select : 1;
+    uint32_t    skip_mode_present : 1;
+    uint32_t    delta_q_present : 1;
+    uint32_t    delta_lf_present : 1;
+    uint32_t    delta_lf_multi : 1;
+    uint32_t    segmentation_enabled : 1;
+    uint32_t    segmentation_update_map : 1;
+    uint32_t    segmentation_temporal_update : 1;
+    uint32_t    segmentation_update_data : 1;
+    uint32_t    UsesLr : 1;
+    uint32_t    usesChromaLr : 1;
+    uint32_t    apply_grain : 1;
+    uint32_t    reserved : 3;
+} StdVideoDecodeAV1PictureInfoFlags;
+
+typedef struct StdVideoDecodeAV1PictureInfo {
+    StdVideoDecodeAV1PictureInfoFlags    flags;
+    StdVideoAV1FrameType                 frame_type;
+    uint32_t                             current_frame_id;
+    uint8_t                              OrderHint;
+    uint8_t                              primary_ref_frame;
+    uint8_t                              refresh_frame_flags;
+    uint8_t                              reserved1;
+    StdVideoAV1InterpolationFilter       interpolation_filter;
+    StdVideoAV1TxMode                    TxMode;
+    uint8_t                              delta_q_res;
+    uint8_t                              delta_lf_res;
+    uint8_t                              SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES];
+    uint8_t                              coded_denom;
+    uint8_t                              reserved2[3];
+    uint8_t                              OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    uint32_t                             expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES];
+    const StdVideoAV1TileInfo*           pTileInfo;
+    const StdVideoAV1Quantization*       pQuantization;
+    const StdVideoAV1Segmentation*       pSegmentation;
+    const StdVideoAV1LoopFilter*         pLoopFilter;
+    const StdVideoAV1CDEF*               pCDEF;
+    const StdVideoAV1LoopRestoration*    pLoopRestoration;
+    const StdVideoAV1GlobalMotion*       pGlobalMotion;
+    const StdVideoAV1FilmGrain*          pFilmGrain;
+} StdVideoDecodeAV1PictureInfo;
+
+typedef struct StdVideoDecodeAV1ReferenceInfoFlags {
+    uint32_t    disable_frame_end_update_cdf : 1;
+    uint32_t    segmentation_enabled : 1;
+    uint32_t    reserved : 30;
+} StdVideoDecodeAV1ReferenceInfoFlags;
+
+typedef struct StdVideoDecodeAV1ReferenceInfo {
+    StdVideoDecodeAV1ReferenceInfoFlags    flags;
+    uint8_t                                frame_type;
+    uint8_t                                RefFrameSignBias;
+    uint8_t                                OrderHint;
+    uint8_t                                SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES];
+} StdVideoDecodeAV1ReferenceInfo;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/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/vk_video/vulkan_video_codec_h264std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -22,13 +22,14 @@ extern "C" {
 // vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h264std 1
 #include "vulkan_video_codecs_common.h"
-#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE  32
-#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6
-#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16
-#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6
-#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64
-#define STD_VIDEO_H264_MAX_NUM_LIST_REF   32
-#define STD_VIDEO_H264_MAX_CHROMA_PLANES  2
+#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE  32U
+#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6U
+#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16U
+#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6U
+#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64U
+#define STD_VIDEO_H264_MAX_NUM_LIST_REF   32U
+#define STD_VIDEO_H264_MAX_CHROMA_PLANES  2U
+#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFFU
 
 typedef enum StdVideoH264ChromaFormatIdc {
     STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0,

include/vk_video/vulkan_video_codec_h264std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -27,7 +27,7 @@ extern "C" {
 
 #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode"
-#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2
+#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2U
 
 typedef enum StdVideoDecodeH264FieldOrderCount {
     STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0,

include/vk_video/vulkan_video_codec_h264std_encode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -22,10 +22,10 @@ extern "C" {
 // vulkan_video_codec_h264std_encode is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h264std_encode 1
 #include "vulkan_video_codec_h264std.h"
-// Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number
-#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10)
 
-#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_10
+#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode"
 typedef struct StdVideoEncodeH264WeightTableFlags {
     uint32_t    luma_weight_l0_flag;
@@ -81,7 +81,7 @@ typedef struct StdVideoEncodeH264RefListModEntry {
 } StdVideoEncodeH264RefListModEntry;
 
 typedef struct StdVideoEncodeH264RefPicMarkingEntry {
-    StdVideoH264MemMgmtControlOp    operation;
+    StdVideoH264MemMgmtControlOp    memory_management_control_operation;
     uint16_t                        difference_of_pic_nums_minus1;
     uint16_t                        long_term_pic_num;
     uint16_t                        long_term_frame_idx;
@@ -132,7 +132,8 @@ typedef struct StdVideoEncodeH264SliceHeader {
     StdVideoH264SliceType                     slice_type;
     int8_t                                    slice_alpha_c0_offset_div2;
     int8_t                                    slice_beta_offset_div2;
-    uint16_t                                  reserved1;
+    int8_t                                    slice_qp_delta;
+    uint8_t                                   reserved1;
     StdVideoH264CabacInitIdc                  cabac_init_idc;
     StdVideoH264DisableDeblockingFilterIdc    disable_deblocking_filter_idc;
     const StdVideoEncodeH264WeightTable*      pWeightTable;

include/vk_video/vulkan_video_codec_h265std.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -22,28 +22,29 @@ extern "C" {
 // vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h265std 1
 #include "vulkan_video_codecs_common.h"
-#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE  32
-#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7
-#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6
-#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16
-#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6
-#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64
-#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6
-#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64
-#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2
-#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19
-#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21
-#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3
-#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128
-#define STD_VIDEO_H265_MAX_NUM_LIST_REF   15
-#define STD_VIDEO_H265_MAX_CHROMA_PLANES  2
-#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64
-#define STD_VIDEO_H265_MAX_DPB_SIZE       16
-#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32
-#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16
-#define STD_VIDEO_H265_MAX_DELTA_POC      48
+#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE  32U
+#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7U
+#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6U
+#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16U
+#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6U
+#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64U
+#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6U
+#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64U
+#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2U
+#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64U
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6U
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19U
+#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21U
+#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3U
+#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128U
+#define STD_VIDEO_H265_MAX_NUM_LIST_REF   15U
+#define STD_VIDEO_H265_MAX_CHROMA_PLANES  2U
+#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64U
+#define STD_VIDEO_H265_MAX_DPB_SIZE       16U
+#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32U
+#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16U
+#define STD_VIDEO_H265_MAX_DELTA_POC      48U
+#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFFU
 
 typedef enum StdVideoH265ChromaFormatIdc {
     STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0,

include/vk_video/vulkan_video_codec_h265std_decode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -27,7 +27,7 @@ extern "C" {
 
 #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode"
-#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8
+#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8U
 typedef struct StdVideoDecodeH265PictureInfoFlags {
     uint32_t    IrapPicFlag : 1;
     uint32_t    IdrPicFlag  : 1;

include/vk_video/vulkan_video_codec_h265std_encode.h

@@ -2,7 +2,7 @@
 #define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -22,10 +22,10 @@ extern "C" {
 // vulkan_video_codec_h265std_encode is a preprocessor guard. Do not pass it to API calls.
 #define vulkan_video_codec_h265std_encode 1
 #include "vulkan_video_codec_h265std.h"
-// Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number
-#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_11 VK_MAKE_VIDEO_STD_VERSION(0, 9, 11)
 
-#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_11
+#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0
 #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode"
 typedef struct StdVideoEncodeH265WeightTableFlags {
     uint16_t    luma_weight_l0_flag;
@@ -77,7 +77,8 @@ typedef struct StdVideoEncodeH265SliceSegmentHeader {
     int8_t                                       slice_act_y_qp_offset;
     int8_t                                       slice_act_cb_qp_offset;
     int8_t                                       slice_act_cr_qp_offset;
-    uint8_t                                      reserved1[3];
+    int8_t                                       slice_qp_delta;
+    uint16_t                                     reserved1;
     const StdVideoEncodeH265WeightTable*         pWeightTable;
 } StdVideoEncodeH265SliceSegmentHeader;
 
@@ -110,7 +111,7 @@ typedef struct StdVideoEncodeH265PictureInfoFlags {
     uint32_t    reserved : 23;
 } StdVideoEncodeH265PictureInfoFlags;
 
-typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics {
+typedef struct StdVideoEncodeH265LongTermRefPics {
     uint8_t     num_long_term_sps;
     uint8_t     num_long_term_pics;
     uint8_t     lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS];
@@ -118,7 +119,7 @@ typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics {
     uint16_t    used_by_curr_pic_lt_flag;
     uint8_t     delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC];
     uint8_t     delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC];
-} StdVideoEncodeH265SliceSegmentLongTermRefPics;
+} StdVideoEncodeH265LongTermRefPics;
 
 typedef struct StdVideoEncodeH265PictureInfo {
     StdVideoEncodeH265PictureInfoFlags             flags;
@@ -132,7 +133,7 @@ typedef struct StdVideoEncodeH265PictureInfo {
     uint8_t                                        reserved1[7];
     const StdVideoEncodeH265ReferenceListsInfo*    pRefLists;
     const StdVideoH265ShortTermRefPicSet*          pShortTermRefPicSet;
-    const StdVideoEncodeH265SliceSegmentLongTermRefPics*    pLongTermRefPics;
+    const StdVideoEncodeH265LongTermRefPics*       pLongTermRefPics;
 } StdVideoEncodeH265PictureInfo;
 
 typedef struct StdVideoEncodeH265ReferenceInfoFlags {

include/vk_video/vulkan_video_codec_vp9std.h

@@ -0,0 +1,151 @@
+#ifndef VULKAN_VIDEO_CODEC_VP9STD_H_
+#define VULKAN_VIDEO_CODEC_VP9STD_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_vp9std is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_vp9std 1
+#include "vulkan_video_codecs_common.h"
+#define STD_VIDEO_VP9_NUM_REF_FRAMES      8U
+#define STD_VIDEO_VP9_REFS_PER_FRAME      3U
+#define STD_VIDEO_VP9_MAX_REF_FRAMES      4U
+#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2U
+#define STD_VIDEO_VP9_MAX_SEGMENTS        8U
+#define STD_VIDEO_VP9_SEG_LVL_MAX         4U
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7U
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3U
+
+typedef enum StdVideoVP9Profile {
+    STD_VIDEO_VP9_PROFILE_0 = 0,
+    STD_VIDEO_VP9_PROFILE_1 = 1,
+    STD_VIDEO_VP9_PROFILE_2 = 2,
+    STD_VIDEO_VP9_PROFILE_3 = 3,
+    STD_VIDEO_VP9_PROFILE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_PROFILE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9Profile;
+
+typedef enum StdVideoVP9Level {
+    STD_VIDEO_VP9_LEVEL_1_0 = 0,
+    STD_VIDEO_VP9_LEVEL_1_1 = 1,
+    STD_VIDEO_VP9_LEVEL_2_0 = 2,
+    STD_VIDEO_VP9_LEVEL_2_1 = 3,
+    STD_VIDEO_VP9_LEVEL_3_0 = 4,
+    STD_VIDEO_VP9_LEVEL_3_1 = 5,
+    STD_VIDEO_VP9_LEVEL_4_0 = 6,
+    STD_VIDEO_VP9_LEVEL_4_1 = 7,
+    STD_VIDEO_VP9_LEVEL_5_0 = 8,
+    STD_VIDEO_VP9_LEVEL_5_1 = 9,
+    STD_VIDEO_VP9_LEVEL_5_2 = 10,
+    STD_VIDEO_VP9_LEVEL_6_0 = 11,
+    STD_VIDEO_VP9_LEVEL_6_1 = 12,
+    STD_VIDEO_VP9_LEVEL_6_2 = 13,
+    STD_VIDEO_VP9_LEVEL_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9Level;
+
+typedef enum StdVideoVP9FrameType {
+    STD_VIDEO_VP9_FRAME_TYPE_KEY = 0,
+    STD_VIDEO_VP9_FRAME_TYPE_NON_KEY = 1,
+    STD_VIDEO_VP9_FRAME_TYPE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9FrameType;
+
+typedef enum StdVideoVP9ReferenceName {
+    STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME = 0,
+    STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME = 1,
+    STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME = 2,
+    STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME = 3,
+    STD_VIDEO_VP9_REFERENCE_NAME_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9ReferenceName;
+
+typedef enum StdVideoVP9InterpolationFilter {
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP = 0,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR = 3,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE = 4,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9InterpolationFilter;
+
+typedef enum StdVideoVP9ColorSpace {
+    STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN = 0,
+    STD_VIDEO_VP9_COLOR_SPACE_BT_601 = 1,
+    STD_VIDEO_VP9_COLOR_SPACE_BT_709 = 2,
+    STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170 = 3,
+    STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240 = 4,
+    STD_VIDEO_VP9_COLOR_SPACE_BT_2020 = 5,
+    STD_VIDEO_VP9_COLOR_SPACE_RESERVED = 6,
+    STD_VIDEO_VP9_COLOR_SPACE_RGB = 7,
+    STD_VIDEO_VP9_COLOR_SPACE_INVALID = 0x7FFFFFFF,
+    STD_VIDEO_VP9_COLOR_SPACE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9ColorSpace;
+typedef struct StdVideoVP9ColorConfigFlags {
+    uint32_t    color_range : 1;
+    uint32_t    reserved : 31;
+} StdVideoVP9ColorConfigFlags;
+
+typedef struct StdVideoVP9ColorConfig {
+    StdVideoVP9ColorConfigFlags    flags;
+    uint8_t                        BitDepth;
+    uint8_t                        subsampling_x;
+    uint8_t                        subsampling_y;
+    uint8_t                        reserved1;
+    StdVideoVP9ColorSpace          color_space;
+} StdVideoVP9ColorConfig;
+
+typedef struct StdVideoVP9LoopFilterFlags {
+    uint32_t    loop_filter_delta_enabled : 1;
+    uint32_t    loop_filter_delta_update : 1;
+    uint32_t    reserved : 30;
+} StdVideoVP9LoopFilterFlags;
+
+typedef struct StdVideoVP9LoopFilter {
+    StdVideoVP9LoopFilterFlags    flags;
+    uint8_t                       loop_filter_level;
+    uint8_t                       loop_filter_sharpness;
+    uint8_t                       update_ref_delta;
+    int8_t                        loop_filter_ref_deltas[STD_VIDEO_VP9_MAX_REF_FRAMES];
+    uint8_t                       update_mode_delta;
+    int8_t                        loop_filter_mode_deltas[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS];
+} StdVideoVP9LoopFilter;
+
+typedef struct StdVideoVP9SegmentationFlags {
+    uint32_t    segmentation_update_map : 1;
+    uint32_t    segmentation_temporal_update : 1;
+    uint32_t    segmentation_update_data : 1;
+    uint32_t    segmentation_abs_or_delta_update : 1;
+    uint32_t    reserved : 28;
+} StdVideoVP9SegmentationFlags;
+
+typedef struct StdVideoVP9Segmentation {
+    StdVideoVP9SegmentationFlags    flags;
+    uint8_t                         segmentation_tree_probs[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS];
+    uint8_t                         segmentation_pred_prob[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB];
+    uint8_t                         FeatureEnabled[STD_VIDEO_VP9_MAX_SEGMENTS];
+    int16_t                         FeatureData[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX];
+} StdVideoVP9Segmentation;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/vk_video/vulkan_video_codec_vp9std_decode.h

@@ -0,0 +1,68 @@
+#ifndef VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_
+#define VULKAN_VIDEO_CODEC_VP9STD_DECODE_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_vp9std_decode is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_vp9std_decode 1
+#include "vulkan_video_codec_vp9std.h"
+
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_vp9_decode"
+typedef struct StdVideoDecodeVP9PictureInfoFlags {
+    uint32_t    error_resilient_mode : 1;
+    uint32_t    intra_only : 1;
+    uint32_t    allow_high_precision_mv : 1;
+    uint32_t    refresh_frame_context : 1;
+    uint32_t    frame_parallel_decoding_mode : 1;
+    uint32_t    segmentation_enabled : 1;
+    uint32_t    show_frame : 1;
+    uint32_t    UsePrevFrameMvs : 1;
+    uint32_t    reserved : 24;
+} StdVideoDecodeVP9PictureInfoFlags;
+
+typedef struct StdVideoDecodeVP9PictureInfo {
+    StdVideoDecodeVP9PictureInfoFlags    flags;
+    StdVideoVP9Profile                   profile;
+    StdVideoVP9FrameType                 frame_type;
+    uint8_t                              frame_context_idx;
+    uint8_t                              reset_frame_context;
+    uint8_t                              refresh_frame_flags;
+    uint8_t                              ref_frame_sign_bias_mask;
+    StdVideoVP9InterpolationFilter       interpolation_filter;
+    uint8_t                              base_q_idx;
+    int8_t                               delta_q_y_dc;
+    int8_t                               delta_q_uv_dc;
+    int8_t                               delta_q_uv_ac;
+    uint8_t                              tile_cols_log2;
+    uint8_t                              tile_rows_log2;
+    uint16_t                             reserved1[3];
+    const StdVideoVP9ColorConfig*        pColorConfig;
+    const StdVideoVP9LoopFilter*         pLoopFilter;
+    const StdVideoVP9Segmentation*       pSegmentation;
+} StdVideoDecodeVP9PictureInfo;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/vk_video/vulkan_video_codecs_common.h

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

include/vulkan/vk_platform.h

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

include/vulkan/vulkan.h

@@ -2,7 +2,7 @@
 #define VULKAN_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -96,4 +96,8 @@
 #include "vulkan_beta.h"
 #endif
 
+#ifdef VK_USE_PLATFORM_OHOS
+#include "vulkan_ohos.h"
+#endif
+
 #endif // VULKAN_H_

include/vulkan/vulkan_android.h

@@ -2,7 +2,7 @@
 #define VULKAN_ANDROID_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -35,12 +35,14 @@ typedef struct VkAndroidSurfaceCreateInfoKHR {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
     VkInstance                                  instance,
     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
+#endif
 
 
 // VK_ANDROID_external_memory_android_hardware_buffer is a preprocessor guard. Do not pass it to API calls.
@@ -109,16 +111,46 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(Vk
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
     VkDevice                                    device,
     const struct AHardwareBuffer*               buffer,
     VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
     VkDevice                                    device,
     const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
     struct AHardwareBuffer**                    pBuffer);
 #endif
+#endif
+
+
+// VK_ANDROID_external_format_resolve is a preprocessor guard. Do not pass it to API calls.
+#define VK_ANDROID_external_format_resolve 1
+#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION 1
+#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME "VK_ANDROID_external_format_resolve"
+typedef struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           externalFormatResolve;
+} VkPhysicalDeviceExternalFormatResolveFeaturesANDROID;
+
+typedef struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID {
+    VkStructureType     sType;
+    void*               pNext;
+    VkBool32            nullColorAttachmentWithExternalFormatResolve;
+    VkChromaLocation    externalFormatResolveChromaOffsetX;
+    VkChromaLocation    externalFormatResolveChromaOffsetY;
+} VkPhysicalDeviceExternalFormatResolvePropertiesANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    VkFormat           colorAttachmentFormat;
+} VkAndroidHardwareBufferFormatResolvePropertiesANDROID;
+
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_beta.h

@@ -2,7 +2,7 @@
 #define VULKAN_BETA_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -51,607 +51,16 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
 
 
 
-// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls.
-#define VK_KHR_video_encode_queue 1
-#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 9
-#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
-
-typedef enum VkVideoEncodeTuningModeKHR {
-    VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1,
-    VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2,
-    VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3,
-    VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4,
-    VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeTuningModeKHR;
-typedef VkFlags VkVideoEncodeFlagsKHR;
-
-typedef enum VkVideoEncodeCapabilityFlagBitsKHR {
-    VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeCapabilityFlagBitsKHR;
-typedef VkFlags VkVideoEncodeCapabilityFlagsKHR;
-
-typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeRateControlModeFlagBitsKHR;
-typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
-
-typedef enum VkVideoEncodeFeedbackFlagBitsKHR {
-    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeFeedbackFlagBitsKHR;
-typedef VkFlags VkVideoEncodeFeedbackFlagsKHR;
-
-typedef enum VkVideoEncodeUsageFlagBitsKHR {
-    VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008,
-    VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeUsageFlagBitsKHR;
-typedef VkFlags VkVideoEncodeUsageFlagsKHR;
-
-typedef enum VkVideoEncodeContentFlagBitsKHR {
-    VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0,
-    VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001,
-    VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002,
-    VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004,
-    VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoEncodeContentFlagBitsKHR;
-typedef VkFlags VkVideoEncodeContentFlagsKHR;
-typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
-typedef struct VkVideoEncodeInfoKHR {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkVideoEncodeFlagsKHR                 flags;
-    VkBuffer                              dstBuffer;
-    VkDeviceSize                          dstBufferOffset;
-    VkDeviceSize                          dstBufferRange;
-    VkVideoPictureResourceInfoKHR         srcPictureResource;
-    const VkVideoReferenceSlotInfoKHR*    pSetupReferenceSlot;
-    uint32_t                              referenceSlotCount;
-    const VkVideoReferenceSlotInfoKHR*    pReferenceSlots;
-    uint32_t                              precedingExternallyEncodedBytes;
-} VkVideoEncodeInfoKHR;
-
-typedef struct VkVideoEncodeCapabilitiesKHR {
-    VkStructureType                         sType;
-    void*                                   pNext;
-    VkVideoEncodeCapabilityFlagsKHR         flags;
-    VkVideoEncodeRateControlModeFlagsKHR    rateControlModes;
-    uint32_t                                maxRateControlLayers;
-    uint64_t                                maxBitrate;
-    uint32_t                                maxQualityLevels;
-    VkExtent2D                              encodeInputPictureGranularity;
-    VkVideoEncodeFeedbackFlagsKHR           supportedEncodeFeedbackFlags;
-} VkVideoEncodeCapabilitiesKHR;
-
-typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkVideoEncodeFeedbackFlagsKHR    encodeFeedbackFlags;
-} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR;
-
-typedef struct VkVideoEncodeUsageInfoKHR {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkVideoEncodeUsageFlagsKHR      videoUsageHints;
-    VkVideoEncodeContentFlagsKHR    videoContentHints;
-    VkVideoEncodeTuningModeKHR      tuningMode;
-} VkVideoEncodeUsageInfoKHR;
-
-typedef struct VkVideoEncodeRateControlLayerInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint64_t           averageBitrate;
-    uint64_t           maxBitrate;
-    uint32_t           frameRateNumerator;
-    uint32_t           frameRateDenominator;
-} VkVideoEncodeRateControlLayerInfoKHR;
-
-typedef struct VkVideoEncodeRateControlInfoKHR {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    VkVideoEncodeRateControlFlagsKHR               flags;
-    VkVideoEncodeRateControlModeFlagBitsKHR        rateControlMode;
-    uint32_t                                       layerCount;
-    const VkVideoEncodeRateControlLayerInfoKHR*    pLayers;
-    uint32_t                                       virtualBufferSizeInMs;
-    uint32_t                                       initialVirtualBufferSizeInMs;
-} VkVideoEncodeRateControlInfoKHR;
-
-typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    const VkVideoProfileInfoKHR*    pVideoProfile;
-    uint32_t                        qualityLevel;
-} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR;
-
-typedef struct VkVideoEncodeQualityLevelPropertiesKHR {
-    VkStructureType                            sType;
-    void*                                      pNext;
-    VkVideoEncodeRateControlModeFlagBitsKHR    preferredRateControlMode;
-    uint32_t                                   preferredRateControlLayerCount;
-} VkVideoEncodeQualityLevelPropertiesKHR;
-
-typedef struct VkVideoEncodeQualityLevelInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           qualityLevel;
-} VkVideoEncodeQualityLevelInfoKHR;
-
-typedef struct VkVideoEncodeSessionParametersGetInfoKHR {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkVideoSessionParametersKHR    videoSessionParameters;
-} VkVideoEncodeSessionParametersGetInfoKHR;
-
-typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           hasOverrides;
-} VkVideoEncodeSessionParametersFeedbackInfoKHR;
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData);
-typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo,
-    VkVideoEncodeQualityLevelPropertiesKHR*     pQualityLevelProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(
-    VkDevice                                    device,
-    const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo,
-    VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo,
-    size_t*                                     pDataSize,
-    void*                                       pData);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
-    VkCommandBuffer                             commandBuffer,
-    const VkVideoEncodeInfoKHR*                 pEncodeInfo);
-#endif
-
-
-// VK_EXT_video_encode_h264 is a preprocessor guard. Do not pass it to API calls.
-#define VK_EXT_video_encode_h264 1
-#include "vk_video/vulkan_video_codec_h264std.h"
-#include "vk_video/vulkan_video_codec_h264std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 11
-#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
-
-typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
-    VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264CapabilityFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
-
-typedef enum VkVideoEncodeH264StdFlagBitsEXT {
-    VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT = 0x00000200,
-    VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT = 0x00000400,
-    VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT = 0x00000800,
-    VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT = 0x00001000,
-    VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT = 0x00002000,
-    VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000,
-    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00008000,
-    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00010000,
-    VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00020000,
-    VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264StdFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264StdFlagsEXT;
-
-typedef enum VkVideoEncodeH264RateControlFlagBitsEXT {
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264RateControlFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264RateControlFlagsEXT;
-typedef struct VkVideoEncodeH264CapabilitiesEXT {
-    VkStructureType                        sType;
-    void*                                  pNext;
-    VkVideoEncodeH264CapabilityFlagsEXT    flags;
-    StdVideoH264LevelIdc                   maxLevelIdc;
-    uint32_t                               maxSliceCount;
-    uint32_t                               maxPPictureL0ReferenceCount;
-    uint32_t                               maxBPictureL0ReferenceCount;
-    uint32_t                               maxL1ReferenceCount;
-    uint32_t                               maxTemporalLayerCount;
-    VkBool32                               expectDyadicTemporalLayerPattern;
-    int32_t                                minQp;
-    int32_t                                maxQp;
-    VkBool32                               prefersGopRemainingFrames;
-    VkBool32                               requiresGopRemainingFrames;
-    VkVideoEncodeH264StdFlagsEXT           stdSyntaxFlags;
-} VkVideoEncodeH264CapabilitiesEXT;
-
-typedef struct VkVideoEncodeH264QpEXT {
-    int32_t    qpI;
-    int32_t    qpP;
-    int32_t    qpB;
-} VkVideoEncodeH264QpEXT;
-
-typedef struct VkVideoEncodeH264QualityLevelPropertiesEXT {
-    VkStructureType                         sType;
-    void*                                   pNext;
-    VkVideoEncodeH264RateControlFlagsEXT    preferredRateControlFlags;
-    uint32_t                                preferredGopFrameCount;
-    uint32_t                                preferredIdrPeriod;
-    uint32_t                                preferredConsecutiveBFrameCount;
-    uint32_t                                preferredTemporalLayerCount;
-    VkVideoEncodeH264QpEXT                  preferredConstantQp;
-    uint32_t                                preferredMaxL0ReferenceCount;
-    uint32_t                                preferredMaxL1ReferenceCount;
-    VkBool32                                preferredStdEntropyCodingModeFlag;
-} VkVideoEncodeH264QualityLevelPropertiesEXT;
-
-typedef struct VkVideoEncodeH264SessionCreateInfoEXT {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkBool32                useMaxLevelIdc;
-    StdVideoH264LevelIdc    maxLevelIdc;
-} VkVideoEncodeH264SessionCreateInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {
-    VkStructureType                            sType;
-    const void*                                pNext;
-    uint32_t                                   stdSPSCount;
-    const StdVideoH264SequenceParameterSet*    pStdSPSs;
-    uint32_t                                   stdPPSCount;
-    const StdVideoH264PictureParameterSet*     pStdPPSs;
-} VkVideoEncodeH264SessionParametersAddInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
-    VkStructureType                                        sType;
-    const void*                                            pNext;
-    uint32_t                                               maxStdSPSCount;
-    uint32_t                                               maxStdPPSCount;
-    const VkVideoEncodeH264SessionParametersAddInfoEXT*    pParametersAddInfo;
-} VkVideoEncodeH264SessionParametersCreateInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersGetInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           writeStdSPS;
-    VkBool32           writeStdPPS;
-    uint32_t           stdSPSId;
-    uint32_t           stdPPSId;
-} VkVideoEncodeH264SessionParametersGetInfoEXT;
-
-typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           hasStdSPSOverrides;
-    VkBool32           hasStdPPSOverrides;
-} VkVideoEncodeH264SessionParametersFeedbackInfoEXT;
-
-typedef struct VkVideoEncodeH264NaluSliceInfoEXT {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    int32_t                                 constantQp;
-    const StdVideoEncodeH264SliceHeader*    pStdSliceHeader;
-} VkVideoEncodeH264NaluSliceInfoEXT;
-
-typedef struct VkVideoEncodeH264PictureInfoEXT {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    uint32_t                                    naluSliceEntryCount;
-    const VkVideoEncodeH264NaluSliceInfoEXT*    pNaluSliceEntries;
-    const StdVideoEncodeH264PictureInfo*        pStdPictureInfo;
-    VkBool32                                    generatePrefixNalu;
-} VkVideoEncodeH264PictureInfoEXT;
-
-typedef struct VkVideoEncodeH264DpbSlotInfoEXT {
-    VkStructureType                           sType;
-    const void*                               pNext;
-    const StdVideoEncodeH264ReferenceInfo*    pStdReferenceInfo;
-} VkVideoEncodeH264DpbSlotInfoEXT;
-
-typedef struct VkVideoEncodeH264ProfileInfoEXT {
-    VkStructureType           sType;
-    const void*               pNext;
-    StdVideoH264ProfileIdc    stdProfileIdc;
-} VkVideoEncodeH264ProfileInfoEXT;
-
-typedef struct VkVideoEncodeH264RateControlInfoEXT {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkVideoEncodeH264RateControlFlagsEXT    flags;
-    uint32_t                                gopFrameCount;
-    uint32_t                                idrPeriod;
-    uint32_t                                consecutiveBFrameCount;
-    uint32_t                                temporalLayerCount;
-} VkVideoEncodeH264RateControlInfoEXT;
-
-typedef struct VkVideoEncodeH264FrameSizeEXT {
-    uint32_t    frameISize;
-    uint32_t    framePSize;
-    uint32_t    frameBSize;
-} VkVideoEncodeH264FrameSizeEXT;
-
-typedef struct VkVideoEncodeH264RateControlLayerInfoEXT {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkBool32                         useMinQp;
-    VkVideoEncodeH264QpEXT           minQp;
-    VkBool32                         useMaxQp;
-    VkVideoEncodeH264QpEXT           maxQp;
-    VkBool32                         useMaxFrameSize;
-    VkVideoEncodeH264FrameSizeEXT    maxFrameSize;
-} VkVideoEncodeH264RateControlLayerInfoEXT;
-
-typedef struct VkVideoEncodeH264GopRemainingFrameInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           useGopRemainingFrames;
-    uint32_t           gopRemainingI;
-    uint32_t           gopRemainingP;
-    uint32_t           gopRemainingB;
-} VkVideoEncodeH264GopRemainingFrameInfoEXT;
-
-
-
-// VK_EXT_video_encode_h265 is a preprocessor guard. Do not pass it to API calls.
-#define VK_EXT_video_encode_h265 1
-#include "vk_video/vulkan_video_codec_h265std.h"
-#include "vk_video/vulkan_video_codec_h265std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 11
-#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265"
-
-typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT = 0x00000200,
-    VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265CapabilityFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT;
-
-typedef enum VkVideoEncodeH265StdFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT = 0x00000020,
-    VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT = 0x00000040,
-    VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT = 0x00000080,
-    VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000100,
-    VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT = 0x00000200,
-    VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT = 0x00000400,
-    VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT = 0x00000800,
-    VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT = 0x00001000,
-    VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT = 0x00002000,
-    VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT = 0x00004000,
-    VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT = 0x00008000,
-    VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT = 0x00010000,
-    VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT = 0x00020000,
-    VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT = 0x00040000,
-    VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265StdFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265StdFlagsEXT;
-
-typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265CtbSizeFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT;
-
-typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265TransformBlockSizeFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT;
-
-typedef enum VkVideoEncodeH265RateControlFlagBitsEXT {
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT = 0x00000001,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT = 0x00000002,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT = 0x00000004,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT = 0x00000008,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT = 0x00000010,
-    VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH265RateControlFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH265RateControlFlagsEXT;
-typedef struct VkVideoEncodeH265CapabilitiesEXT {
-    VkStructureType                                sType;
-    void*                                          pNext;
-    VkVideoEncodeH265CapabilityFlagsEXT            flags;
-    StdVideoH265LevelIdc                           maxLevelIdc;
-    uint32_t                                       maxSliceSegmentCount;
-    VkExtent2D                                     maxTiles;
-    VkVideoEncodeH265CtbSizeFlagsEXT               ctbSizes;
-    VkVideoEncodeH265TransformBlockSizeFlagsEXT    transformBlockSizes;
-    uint32_t                                       maxPPictureL0ReferenceCount;
-    uint32_t                                       maxBPictureL0ReferenceCount;
-    uint32_t                                       maxL1ReferenceCount;
-    uint32_t                                       maxSubLayerCount;
-    VkBool32                                       expectDyadicTemporalSubLayerPattern;
-    int32_t                                        minQp;
-    int32_t                                        maxQp;
-    VkBool32                                       prefersGopRemainingFrames;
-    VkBool32                                       requiresGopRemainingFrames;
-    VkVideoEncodeH265StdFlagsEXT                   stdSyntaxFlags;
-} VkVideoEncodeH265CapabilitiesEXT;
-
-typedef struct VkVideoEncodeH265SessionCreateInfoEXT {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkBool32                useMaxLevelIdc;
-    StdVideoH265LevelIdc    maxLevelIdc;
-} VkVideoEncodeH265SessionCreateInfoEXT;
-
-typedef struct VkVideoEncodeH265QpEXT {
-    int32_t    qpI;
-    int32_t    qpP;
-    int32_t    qpB;
-} VkVideoEncodeH265QpEXT;
-
-typedef struct VkVideoEncodeH265QualityLevelPropertiesEXT {
-    VkStructureType                         sType;
-    void*                                   pNext;
-    VkVideoEncodeH265RateControlFlagsEXT    preferredRateControlFlags;
-    uint32_t                                preferredGopFrameCount;
-    uint32_t                                preferredIdrPeriod;
-    uint32_t                                preferredConsecutiveBFrameCount;
-    uint32_t                                preferredSubLayerCount;
-    VkVideoEncodeH265QpEXT                  preferredConstantQp;
-    uint32_t                                preferredMaxL0ReferenceCount;
-    uint32_t                                preferredMaxL1ReferenceCount;
-} VkVideoEncodeH265QualityLevelPropertiesEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT {
-    VkStructureType                            sType;
-    const void*                                pNext;
-    uint32_t                                   stdVPSCount;
-    const StdVideoH265VideoParameterSet*       pStdVPSs;
-    uint32_t                                   stdSPSCount;
-    const StdVideoH265SequenceParameterSet*    pStdSPSs;
-    uint32_t                                   stdPPSCount;
-    const StdVideoH265PictureParameterSet*     pStdPPSs;
-} VkVideoEncodeH265SessionParametersAddInfoEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT {
-    VkStructureType                                        sType;
-    const void*                                            pNext;
-    uint32_t                                               maxStdVPSCount;
-    uint32_t                                               maxStdSPSCount;
-    uint32_t                                               maxStdPPSCount;
-    const VkVideoEncodeH265SessionParametersAddInfoEXT*    pParametersAddInfo;
-} VkVideoEncodeH265SessionParametersCreateInfoEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersGetInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           writeStdVPS;
-    VkBool32           writeStdSPS;
-    VkBool32           writeStdPPS;
-    uint32_t           stdVPSId;
-    uint32_t           stdSPSId;
-    uint32_t           stdPPSId;
-} VkVideoEncodeH265SessionParametersGetInfoEXT;
-
-typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           hasStdVPSOverrides;
-    VkBool32           hasStdSPSOverrides;
-    VkBool32           hasStdPPSOverrides;
-} VkVideoEncodeH265SessionParametersFeedbackInfoEXT;
-
-typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    int32_t                                        constantQp;
-    const StdVideoEncodeH265SliceSegmentHeader*    pStdSliceSegmentHeader;
-} VkVideoEncodeH265NaluSliceSegmentInfoEXT;
-
-typedef struct VkVideoEncodeH265PictureInfoEXT {
-    VkStructureType                                    sType;
-    const void*                                        pNext;
-    uint32_t                                           naluSliceSegmentEntryCount;
-    const VkVideoEncodeH265NaluSliceSegmentInfoEXT*    pNaluSliceSegmentEntries;
-    const StdVideoEncodeH265PictureInfo*               pStdPictureInfo;
-} VkVideoEncodeH265PictureInfoEXT;
-
-typedef struct VkVideoEncodeH265DpbSlotInfoEXT {
-    VkStructureType                           sType;
-    const void*                               pNext;
-    const StdVideoEncodeH265ReferenceInfo*    pStdReferenceInfo;
-} VkVideoEncodeH265DpbSlotInfoEXT;
-
-typedef struct VkVideoEncodeH265ProfileInfoEXT {
-    VkStructureType           sType;
-    const void*               pNext;
-    StdVideoH265ProfileIdc    stdProfileIdc;
-} VkVideoEncodeH265ProfileInfoEXT;
-
-typedef struct VkVideoEncodeH265RateControlInfoEXT {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkVideoEncodeH265RateControlFlagsEXT    flags;
-    uint32_t                                gopFrameCount;
-    uint32_t                                idrPeriod;
-    uint32_t                                consecutiveBFrameCount;
-    uint32_t                                subLayerCount;
-} VkVideoEncodeH265RateControlInfoEXT;
-
-typedef struct VkVideoEncodeH265FrameSizeEXT {
-    uint32_t    frameISize;
-    uint32_t    framePSize;
-    uint32_t    frameBSize;
-} VkVideoEncodeH265FrameSizeEXT;
-
-typedef struct VkVideoEncodeH265RateControlLayerInfoEXT {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkBool32                         useMinQp;
-    VkVideoEncodeH265QpEXT           minQp;
-    VkBool32                         useMaxQp;
-    VkVideoEncodeH265QpEXT           maxQp;
-    VkBool32                         useMaxFrameSize;
-    VkVideoEncodeH265FrameSizeEXT    maxFrameSize;
-} VkVideoEncodeH265RateControlLayerInfoEXT;
-
-typedef struct VkVideoEncodeH265GopRemainingFrameInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           useGopRemainingFrames;
-    uint32_t           gopRemainingI;
-    uint32_t           gopRemainingP;
-    uint32_t           gopRemainingB;
-} VkVideoEncodeH265GopRemainingFrameInfoEXT;
-
-
-
 // VK_AMDX_shader_enqueue is a preprocessor guard. Do not pass it to API calls.
 #define VK_AMDX_shader_enqueue 1
-#define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 1
+#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 {
@@ -662,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 {
@@ -710,12 +123,13 @@ 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_vkCmdDispatchGraphAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, const VkDispatchGraphCountInfoAMDX*              pCountInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, const VkDispatchGraphCountInfoAMDX*              pCountInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceAddress                                 countInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer                                 commandBuffer, VkPipeline                                      executionGraph, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize);
+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, VkDeviceSize                                    scratchSize, const VkDispatchGraphCountInfoAMDX*             pCountInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, VkDeviceAddress                                 countInfo);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(
     VkDevice                                    device,
     VkPipelineCache                             pipelineCache,
@@ -723,37 +137,159 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(
     const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos,
     const VkAllocationCallbacks*                pAllocator,
     VkPipeline*                                 pPipelines);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX(
     VkDevice                                    device,
     VkPipeline                                  executionGraph,
     VkExecutionGraphPipelineScratchSizeAMDX*    pSizeInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(
     VkDevice                                    device,
     VkPipeline                                  executionGraph,
     const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo,
     uint32_t*                                   pNodeIndex);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(
     VkCommandBuffer                             commandBuffer,
-    VkDeviceAddress                             scratch);
+    VkPipeline                                  executionGraph,
+    VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(
     VkCommandBuffer                             commandBuffer,
     VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
     const VkDispatchGraphCountInfoAMDX*         pCountInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(
     VkCommandBuffer                             commandBuffer,
     VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
     const VkDispatchGraphCountInfoAMDX*         pCountInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(
     VkCommandBuffer                             commandBuffer,
     VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
     VkDeviceAddress                             countInfo);
 #endif
+#endif
+
+
+// VK_NV_cuda_kernel_launch is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_cuda_kernel_launch 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaModuleNV)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaFunctionNV)
+#define VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION 2
+#define VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME "VK_NV_cuda_kernel_launch"
+typedef struct VkCudaModuleCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    size_t             dataSize;
+    const void*        pData;
+} VkCudaModuleCreateInfoNV;
+
+typedef struct VkCudaFunctionCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkCudaModuleNV     module;
+    const char*        pName;
+} VkCudaFunctionCreateInfoNV;
+
+typedef struct VkCudaLaunchInfoNV {
+    VkStructureType        sType;
+    const void*            pNext;
+    VkCudaFunctionNV       function;
+    uint32_t               gridDimX;
+    uint32_t               gridDimY;
+    uint32_t               gridDimZ;
+    uint32_t               blockDimX;
+    uint32_t               blockDimY;
+    uint32_t               blockDimZ;
+    uint32_t               sharedMemBytes;
+    size_t                 paramCount;
+    const void* const *    pParams;
+    size_t                 extraCount;
+    const void* const *    pExtras;
+} VkCudaLaunchInfoNV;
+
+typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           cudaKernelLaunchFeatures;
+} VkPhysicalDeviceCudaKernelLaunchFeaturesNV;
+
+typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           computeCapabilityMinor;
+    uint32_t           computeCapabilityMajor;
+} VkPhysicalDeviceCudaKernelLaunchPropertiesNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule);
+typedef VkResult (VKAPI_PTR *PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction);
+typedef void (VKAPI_PTR *PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo);
+
+#ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV(
+    VkDevice                                    device,
+    const VkCudaModuleCreateInfoNV*             pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkCudaModuleNV*                             pModule);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV(
+    VkDevice                                    device,
+    VkCudaModuleNV                              module,
+    size_t*                                     pCacheSize,
+    void*                                       pCacheData);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV(
+    VkDevice                                    device,
+    const VkCudaFunctionCreateInfoNV*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkCudaFunctionNV*                           pFunction);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV(
+    VkDevice                                    device,
+    VkCudaModuleNV                              module,
+    const VkAllocationCallbacks*                pAllocator);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV(
+    VkDevice                                    device,
+    VkCudaFunctionNV                            function,
+    const VkAllocationCallbacks*                pAllocator);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(
+    VkCommandBuffer                             commandBuffer,
+    const VkCudaLaunchInfoNV*                   pLaunchInfo);
+#endif
+#endif
 
 
 // VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls.
@@ -801,6 +337,37 @@ typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV {
 } VkAccelerationStructureTrianglesDisplacementMicromapNV;
 
 
+
+// VK_AMDX_dense_geometry_format is a preprocessor guard. Do not pass it to API calls.
+#define VK_AMDX_dense_geometry_format 1
+#define VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION 1
+#define VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME "VK_AMDX_dense_geometry_format"
+#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX 128U
+#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX 128U
+
+typedef enum VkCompressedTriangleFormatAMDX {
+    VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX = 0,
+    VK_COMPRESSED_TRIANGLE_FORMAT_MAX_ENUM_AMDX = 0x7FFFFFFF
+} VkCompressedTriangleFormatAMDX;
+typedef struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           denseGeometryFormat;
+} VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX;
+
+typedef struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkDeviceOrHostAddressConstKHR     compressedData;
+    VkDeviceSize                      dataSize;
+    uint32_t                          numTriangles;
+    uint32_t                          numVertices;
+    uint32_t                          maxPrimitiveIndex;
+    uint32_t                          maxGeometryIndex;
+    VkCompressedTriangleFormatAMDX    format;
+} VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
+
+
 #ifdef __cplusplus
 }
 #endif

include/vulkan/vulkan_directfb.h

@@ -2,7 +2,7 @@
 #define VULKAN_DIRECTFB_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -36,17 +36,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(
     VkInstance                                  instance,
     const VkDirectFBSurfaceCreateInfoEXT*       pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
     VkPhysicalDevice                            physicalDevice,
     uint32_t                                    queueFamilyIndex,
     IDirectFB*                                  dfb);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_fuchsia.h

@@ -2,7 +2,7 @@
 #define VULKAN_FUCHSIA_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -34,12 +34,14 @@ typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
     VkInstance                                  instance,
     const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
+#endif
 
 
 // VK_FUCHSIA_external_memory is a preprocessor guard. Do not pass it to API calls.
@@ -70,17 +72,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(
     VkDevice                                    device,
     const VkMemoryGetZirconHandleInfoFUCHSIA*   pGetZirconHandleInfo,
     zx_handle_t*                                pZirconHandle);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(
     VkDevice                                    device,
     VkExternalMemoryHandleTypeFlagBits          handleType,
     zx_handle_t                                 zirconHandle,
     VkMemoryZirconHandlePropertiesFUCHSIA*      pMemoryZirconHandleProperties);
 #endif
+#endif
 
 
 // VK_FUCHSIA_external_semaphore is a preprocessor guard. Do not pass it to API calls.
@@ -107,15 +113,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice
 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(
     VkDevice                                    device,
     const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(
     VkDevice                                    device,
     const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
     zx_handle_t*                                pZirconHandle);
 #endif
+#endif
 
 
 // VK_FUCHSIA_buffer_collection is a preprocessor guard. Do not pass it to API calls.
@@ -228,32 +238,42 @@ typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device,
 typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(
     VkDevice                                    device,
     const VkBufferCollectionCreateInfoFUCHSIA*  pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkBufferCollectionFUCHSIA*                  pCollection);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(
     VkDevice                                    device,
     VkBufferCollectionFUCHSIA                   collection,
     const VkImageConstraintsInfoFUCHSIA*        pImageConstraintsInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(
     VkDevice                                    device,
     VkBufferCollectionFUCHSIA                   collection,
     const VkBufferConstraintsInfoFUCHSIA*       pBufferConstraintsInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(
     VkDevice                                    device,
     VkBufferCollectionFUCHSIA                   collection,
     const VkAllocationCallbacks*                pAllocator);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(
     VkDevice                                    device,
     VkBufferCollectionFUCHSIA                   collection,
     VkBufferCollectionPropertiesFUCHSIA*        pProperties);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_ggp.h

@@ -2,7 +2,7 @@
 #define VULKAN_GGP_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -34,12 +34,14 @@ typedef struct VkStreamDescriptorSurfaceCreateInfoGGP {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(
     VkInstance                                  instance,
     const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
+#endif
 
 
 // VK_GGP_frame_token is a preprocessor guard. Do not pass it to API calls.

include/vulkan/vulkan_hpp_macros.hpp

@@ -0,0 +1,329 @@
+// Copyright 2015-2025 The Khronos Group Inc.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+
+// This header is generated from the Khronos Vulkan XML API Registry.
+
+#ifndef VULKAN_HPP_MACROS_HPP
+#define VULKAN_HPP_MACROS_HPP
+
+#if defined( _MSVC_LANG )
+#  define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
+#else
+#  define VULKAN_HPP_CPLUSPLUS __cplusplus
+#endif
+
+#if 202002L < VULKAN_HPP_CPLUSPLUS
+#  define VULKAN_HPP_CPP_VERSION 23
+#elif 201703L < VULKAN_HPP_CPLUSPLUS
+#  define VULKAN_HPP_CPP_VERSION 20
+#elif 201402L < VULKAN_HPP_CPLUSPLUS
+#  define VULKAN_HPP_CPP_VERSION 17
+#elif 201103L < VULKAN_HPP_CPLUSPLUS
+#  define VULKAN_HPP_CPP_VERSION 14
+#elif 199711L < VULKAN_HPP_CPLUSPLUS
+#  define VULKAN_HPP_CPP_VERSION 11
+#else
+#  error "vulkan.hpp needs at least c++ standard version 11"
+#endif
+
+// include headers holding feature-test macros
+#if 20 <= VULKAN_HPP_CPP_VERSION
+#  include <version>
+#else
+#  include <ciso646>
+#endif
+
+#define VULKAN_HPP_STRINGIFY2( text ) #text
+#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
+#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
+
+#if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ )
+#  define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( GCC warning text ) )
+#elif defined( _MSC_VER )
+#  define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " text ) ) )
+#else
+#  define VULKAN_HPP_COMPILE_WARNING( text )
+#endif
+
+#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+#  if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+#    define VULKAN_HPP_NO_SMART_HANDLE
+#  endif
+#endif
+
+#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
+#  if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+#    define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
+#  endif
+#  if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
+#    define VULKAN_HPP_NO_UNION_CONSTRUCTORS
+#  endif
+#endif
+
+#if defined( VULKAN_HPP_NO_SETTERS )
+#  if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+#    define VULKAN_HPP_NO_STRUCT_SETTERS
+#  endif
+#  if !defined( VULKAN_HPP_NO_UNION_SETTERS )
+#    define VULKAN_HPP_NO_UNION_SETTERS
+#  endif
+#endif
+
+#if !defined( VULKAN_HPP_ASSERT )
+#  define VULKAN_HPP_ASSERT assert
+#endif
+
+#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
+#  define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
+#endif
+
+#if !defined( VULKAN_HPP_STATIC_ASSERT )
+#  define VULKAN_HPP_STATIC_ASSERT static_assert
+#endif
+
+#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
+#  define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
+#endif
+
+#if !defined( __has_include )
+#  define __has_include( x ) false
+#endif
+
+#if defined( __cpp_lib_three_way_comparison ) && ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
+#  define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
+#endif
+
+#if defined( __cpp_lib_span ) && ( 201803 <= __cpp_lib_span )
+#  define VULKAN_HPP_SUPPORT_SPAN
+#endif
+
+#if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) )
+VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." )
+#endif
+
+#ifndef VK_USE_64_BIT_PTR_DEFINES
+#  if defined( __LP64__ ) || defined( _WIN64 ) || ( defined( __x86_64__ ) && !defined( __ILP32__ ) ) || defined( _M_X64 ) || defined( __ia64 ) || \
+    defined( _M_IA64 ) || defined( __aarch64__ ) || defined( __powerpc64__ ) || ( defined( __riscv ) && __riscv_xlen == 64 )
+#    define VK_USE_64_BIT_PTR_DEFINES 1
+#  else
+#    define VK_USE_64_BIT_PTR_DEFINES 0
+#  endif
+#endif
+
+// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
+// To enable this feature on 32-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 1
+// To disable this feature on 64-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 0
+#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
+#  if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+#    define VULKAN_HPP_TYPESAFE_CONVERSION 1
+#  endif
+#endif
+
+#if defined( __GNUC__ )
+#  define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
+#endif
+
+#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
+#  if defined( __clang__ )
+#    if __has_feature( cxx_unrestricted_unions )
+#      define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#    endif
+#  elif defined( __GNUC__ )
+#    if 40600 <= GCC_VERSION
+#      define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#    endif
+#  elif defined( _MSC_VER )
+#    if 1900 <= _MSC_VER
+#      define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+#    endif
+#  endif
+#endif
+
+#if !defined( VULKAN_HPP_INLINE )
+#  if defined( __clang__ )
+#    if __has_attribute( always_inline )
+#      define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+#    else
+#      define VULKAN_HPP_INLINE inline
+#    endif
+#  elif defined( __GNUC__ )
+#    define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+#  elif defined( _MSC_VER )
+#    define VULKAN_HPP_INLINE inline
+#  else
+#    define VULKAN_HPP_INLINE inline
+#  endif
+#endif
+
+#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 )
+#  define VULKAN_HPP_TYPESAFE_EXPLICIT
+#else
+#  define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
+#endif
+
+#if defined( __cpp_constexpr )
+#  define VULKAN_HPP_CONSTEXPR constexpr
+#  if 201304 <= __cpp_constexpr
+#    define VULKAN_HPP_CONSTEXPR_14 constexpr
+#  else
+#    define VULKAN_HPP_CONSTEXPR_14
+#  endif
+#  if 201603 <= __cpp_constexpr
+#    define VULKAN_HPP_CONSTEXPR_17 constexpr
+#  else
+#    define VULKAN_HPP_CONSTEXPR_17
+#  endif
+#  if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) )
+#    define VULKAN_HPP_CONSTEXPR_20 constexpr
+#  else
+#    define VULKAN_HPP_CONSTEXPR_20
+#  endif
+#  define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
+#else
+#  define VULKAN_HPP_CONSTEXPR
+#  define VULKAN_HPP_CONSTEXPR_14
+#  define VULKAN_HPP_CONST_OR_CONSTEXPR const
+#endif
+
+#if !defined( VULKAN_HPP_CONSTEXPR_INLINE )
+#  if 201606L <= __cpp_inline_variables
+#    define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR inline
+#  else
+#    define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR
+#  endif
+#endif
+
+#if !defined( VULKAN_HPP_NOEXCEPT )
+#  if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
+#    define VULKAN_HPP_NOEXCEPT
+#  else
+#    define VULKAN_HPP_NOEXCEPT     noexcept
+#    define VULKAN_HPP_HAS_NOEXCEPT 1
+#    if defined( VULKAN_HPP_NO_EXCEPTIONS )
+#      define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
+#    else
+#      define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+#    endif
+#  endif
+#endif
+
+#if 14 <= VULKAN_HPP_CPP_VERSION
+#  define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
+#else
+#  define VULKAN_HPP_DEPRECATED( msg )
+#endif
+
+#if 17 <= VULKAN_HPP_CPP_VERSION
+#  define VULKAN_HPP_DEPRECATED_17( msg ) [[deprecated( msg )]]
+#else
+#  define VULKAN_HPP_DEPRECATED_17( msg )
+#endif
+
+#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
+#  define VULKAN_HPP_NODISCARD [[nodiscard]]
+#  if defined( VULKAN_HPP_NO_EXCEPTIONS )
+#    define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
+#  else
+#    define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+#  endif
+#else
+#  define VULKAN_HPP_NODISCARD
+#  define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+#endif
+
+#if !defined( VULKAN_HPP_NAMESPACE )
+#  define VULKAN_HPP_NAMESPACE vk
+#endif
+
+#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
+#  if defined( VK_NO_PROTOTYPES )
+#    define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
+#  else
+#    define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
+#  endif
+#endif
+
+#if !defined( VULKAN_HPP_STORAGE_API )
+#  if defined( VULKAN_HPP_STORAGE_SHARED )
+#    if defined( _MSC_VER )
+#      if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+#        define VULKAN_HPP_STORAGE_API __declspec( dllexport )
+#      else
+#        define VULKAN_HPP_STORAGE_API __declspec( dllimport )
+#      endif
+#    elif defined( __clang__ ) || defined( __GNUC__ )
+#      if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+#        define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
+#      else
+#        define VULKAN_HPP_STORAGE_API
+#      endif
+#    else
+#      define VULKAN_HPP_STORAGE_API
+#      pragma warning Unknown import / export semantics
+#    endif
+#  else
+#    define VULKAN_HPP_STORAGE_API
+#  endif
+#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_DISPATCH_LOADER_DYNAMIC_TYPE )
+#  define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic
+#endif
+#if !defined( VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE )
+#  define VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic
+#endif
+
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
+#  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE
+#  else
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE
+#  endif
+#endif
+
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
+#  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic
+#    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE                       \
+      namespace VULKAN_HPP_NAMESPACE                                                 \
+      {                                                                              \
+        namespace detail                                                             \
+        {                                                                            \
+          VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+        }                                                                            \
+      }
+#  else
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic()
+#    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+#  endif
+#endif
+
+#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
+#  define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment )
+#else
+#  define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment
+#endif
+#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT VULKAN_HPP_DEFAULT_ASSIGNMENT( VULKAN_HPP_DEFAULT_DISPATCHER )
+
+#if !defined( VULKAN_HPP_RAII_NAMESPACE )
+#  define VULKAN_HPP_RAII_NAMESPACE        raii
+#  define VULKAN_HPP_RAII_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE )
+#endif
+
+#endif

include/vulkan/vulkan_ios.h

@@ -2,7 +2,7 @@
 #define VULKAN_IOS_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -34,12 +34,14 @@ typedef struct VkIOSSurfaceCreateInfoMVK {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
     VkInstance                                  instance,
     const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_macos.h

@@ -2,7 +2,7 @@
 #define VULKAN_MACOS_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -34,12 +34,14 @@ typedef struct VkMacOSSurfaceCreateInfoMVK {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
     VkInstance                                  instance,
     const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_metal.h

@@ -2,7 +2,7 @@
 #define VULKAN_METAL_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -40,40 +40,42 @@ typedef struct VkMetalSurfaceCreateInfoEXT {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
     VkInstance                                  instance,
     const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
+#endif
 
 
 // VK_EXT_metal_objects is a preprocessor guard. Do not pass it to API calls.
 #define VK_EXT_metal_objects 1
 #ifdef __OBJC__
 @protocol MTLDevice;
-typedef id<MTLDevice> MTLDevice_id;
+typedef __unsafe_unretained id<MTLDevice> MTLDevice_id;
 #else
 typedef void* MTLDevice_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLCommandQueue;
-typedef id<MTLCommandQueue> MTLCommandQueue_id;
+typedef __unsafe_unretained id<MTLCommandQueue> MTLCommandQueue_id;
 #else
 typedef void* MTLCommandQueue_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLBuffer;
-typedef id<MTLBuffer> MTLBuffer_id;
+typedef __unsafe_unretained id<MTLBuffer> MTLBuffer_id;
 #else
 typedef void* MTLBuffer_id;
 #endif
 
 #ifdef __OBJC__
 @protocol MTLTexture;
-typedef id<MTLTexture> MTLTexture_id;
+typedef __unsafe_unretained id<MTLTexture> MTLTexture_id;
 #else
 typedef void* MTLTexture_id;
 #endif
@@ -81,12 +83,12 @@ typedef void* MTLTexture_id;
 typedef struct __IOSurface* IOSurfaceRef;
 #ifdef __OBJC__
 @protocol MTLSharedEvent;
-typedef id<MTLSharedEvent> MTLSharedEvent_id;
+typedef __unsafe_unretained id<MTLSharedEvent> MTLSharedEvent_id;
 #else
 typedef void* MTLSharedEvent_id;
 #endif
 
-#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1
+#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 2
 #define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects"
 
 typedef enum VkExportMetalObjectTypeFlagBitsEXT {
@@ -183,10 +185,57 @@ typedef struct VkImportMetalSharedEventInfoEXT {
 typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
     VkDevice                                    device,
     VkExportMetalObjectsInfoEXT*                pMetalObjectsInfo);
 #endif
+#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
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(
+    VkDevice                                    device,
+    const VkMemoryGetMetalHandleInfoEXT*        pGetMetalHandleInfo,
+    void**                                      pHandle);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    const void*                                 pHandle,
+    VkMemoryMetalHandlePropertiesEXT*           pMemoryMetalHandleProperties);
+#endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_ohos.h

@@ -0,0 +1,182 @@
+#ifndef VULKAN_OHOS_H_
+#define VULKAN_OHOS_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
+
+
+
+// VK_OHOS_external_memory is a preprocessor guard. Do not pass it to API calls.
+#define VK_OHOS_external_memory 1
+struct OH_NativeBuffer;
+#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME "VK_OHOS_external_memory"
+typedef struct VkNativeBufferUsageOHOS {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           OHOSNativeBufferUsage;
+} VkNativeBufferUsageOHOS;
+
+typedef struct VkNativeBufferPropertiesOHOS {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeBits;
+} VkNativeBufferPropertiesOHOS;
+
+typedef struct VkNativeBufferFormatPropertiesOHOS {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkNativeBufferFormatPropertiesOHOS;
+
+typedef struct VkImportNativeBufferInfoOHOS {
+    VkStructureType            sType;
+    const void*                pNext;
+    struct OH_NativeBuffer*    buffer;
+} VkImportNativeBufferInfoOHOS;
+
+typedef struct VkMemoryGetNativeBufferInfoOHOS {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+} VkMemoryGetNativeBufferInfoOHOS;
+
+typedef struct VkExternalFormatOHOS {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           externalFormat;
+} VkExternalFormatOHOS;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetNativeBufferPropertiesOHOS)(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryNativeBufferOHOS)(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS(
+    VkDevice                                    device,
+    const struct OH_NativeBuffer*               buffer,
+    VkNativeBufferPropertiesOHOS*               pProperties);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS(
+    VkDevice                                    device,
+    const VkMemoryGetNativeBufferInfoOHOS*      pInfo,
+    struct OH_NativeBuffer**                    pBuffer);
+#endif
+#endif
+
+
+// VK_OHOS_surface is a preprocessor guard. Do not pass it to API calls.
+#define VK_OHOS_surface 1
+typedef struct NativeWindow OHNativeWindow;
+#define VK_OHOS_SURFACE_SPEC_VERSION      1
+#define VK_OHOS_SURFACE_EXTENSION_NAME    "VK_OHOS_surface"
+typedef VkFlags VkSurfaceCreateFlagsOHOS;
+typedef struct VkSurfaceCreateInfoOHOS {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkSurfaceCreateFlagsOHOS    flags;
+    OHNativeWindow*             window;
+} VkSurfaceCreateInfoOHOS;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSurfaceOHOS)(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(
+    VkInstance                                  instance,
+    const VkSurfaceCreateInfoOHOS*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+#endif
+
+
+// VK_OHOS_native_buffer is a preprocessor guard. Do not pass it to API calls.
+#define VK_OHOS_native_buffer 1
+struct OHBufferHandle;
+#define VK_OHOS_NATIVE_BUFFER_SPEC_VERSION 1
+#define VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME "VK_OHOS_native_buffer"
+
+typedef enum VkSwapchainImageUsageFlagBitsOHOS {
+    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS = 0x00000001,
+    VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_OHOS = 0x7FFFFFFF
+} VkSwapchainImageUsageFlagBitsOHOS;
+typedef VkFlags VkSwapchainImageUsageFlagsOHOS;
+typedef struct VkNativeBufferOHOS {
+    VkStructureType           sType;
+    const void*               pNext;
+    struct OHBufferHandle*    handle;
+} VkNativeBufferOHOS;
+
+typedef struct VkSwapchainImageCreateInfoOHOS {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkSwapchainImageUsageFlagsOHOS    usage;
+} VkSwapchainImageCreateInfoOHOS;
+
+typedef struct VkPhysicalDevicePresentationPropertiesOHOS {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           sharedImage;
+} VkPhysicalDevicePresentationPropertiesOHOS;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageOHOS)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t* grallocUsage);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageOHOS)(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageOHOS)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd);
+
+#ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageOHOS(
+    VkDevice                                    device,
+    VkFormat                                    format,
+    VkImageUsageFlags                           imageUsage,
+    uint64_t*                                   grallocUsage);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageOHOS(
+    VkDevice                                    device,
+    VkImage                                     image,
+    int32_t                                     nativeFenceFd,
+    VkSemaphore                                 semaphore,
+    VkFence                                     fence);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageOHOS(
+    VkQueue                                     queue,
+    uint32_t                                    waitSemaphoreCount,
+    const VkSemaphore*                          pWaitSemaphores,
+    VkImage                                     image,
+    int32_t*                                    pNativeFenceFd);
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/vulkan/vulkan_screen.h

@@ -2,7 +2,7 @@
 #define VULKAN_SCREEN_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -36,17 +36,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance,
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(
     VkInstance                                  instance,
     const VkScreenSurfaceCreateInfoQNX*         pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(
     VkPhysicalDevice                            physicalDevice,
     uint32_t                                    queueFamilyIndex,
     struct _screen_window*                      window);
 #endif
+#endif
 
 
 // VK_QNX_external_memory_screen_buffer is a preprocessor guard. Do not pass it to API calls.
@@ -95,11 +99,13 @@ typedef struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
 typedef VkResult (VKAPI_PTR *PFN_vkGetScreenBufferPropertiesQNX)(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX(
     VkDevice                                    device,
     const struct _screen_buffer*                buffer,
     VkScreenBufferPropertiesQNX*                pProperties);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_vi.h

@@ -2,7 +2,7 @@
 #define VULKAN_VI_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -34,12 +34,14 @@ typedef struct VkViSurfaceCreateInfoNN {
 typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
     VkInstance                                  instance,
     const VkViSurfaceCreateInfoNN*              pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_video.cppm

@@ -0,0 +1,318 @@
+// Copyright 2021-2025 The Khronos Group Inc.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+
+// This header is generated from the Khronos Vulkan XML API Registry.
+
+// Note: This module is still in an experimental state.
+// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
+
+module;
+
+#include <vulkan/vulkan_hpp_macros.hpp>
+#include <vulkan/vulkan_video.hpp>
+
+export module vulkan_video_hpp;
+
+export namespace VULKAN_HPP_NAMESPACE
+{
+  namespace VULKAN_HPP_VIDEO_NAMESPACE
+  {
+
+    //=================
+    //=== CONSTANTs ===
+    //=================
+
+#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
+    //=== vulkan_video_codec_h264std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CpbCntListSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxChromaPlanes;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxNumListRef;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NoReferencePicture;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumElements;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumElements;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumLists;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
+    //=== vulkan_video_codec_h264std_decode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCountListSize;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
+    //=== vulkan_video_codec_h265std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetListSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileColsListSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileRowsListSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265CpbCntListSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxChromaPlanes;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDeltaPoc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDpbSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermPics;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermRefPicsSps;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxNumListRef;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxShortTermRefPicSets;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265NoReferencePicture;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteCompEntriesListSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteComponentsListSize;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumElements;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumElements;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumElements;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumElements;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SublayersListSize;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
+    //=== vulkan_video_codec_h265std_decode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265RefPicSetListSize;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
+    //=== vulkan_video_codec_vp9std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9LoopFilterAdjustments;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxRefFrames;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationPredProb;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationTreeProbs;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegments;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9NumRefFrames;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9RefsPerFrame;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9SegLvlMax;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
+    //=== vulkan_video_codec_av1std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1GlobalMotionParams;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1LoopFilterAdjustments;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxCdefFilterStrengths;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxLoopFilterStrengths;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCbPoints;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCrPoints;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPlanes;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosChroma;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosLuma;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumYPoints;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxSegments;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileCols;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileRows;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1NumRefFrames;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1PrimaryRefNone;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1RefsPerFrame;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SegLvlMax;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectIntegerMv;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectScreenContentTools;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SkipModeFrames;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1TotalRefsPerFrame;
+#endif
+
+    //=============
+    //=== ENUMs ===
+    //=============
+
+#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
+    //=== vulkan_video_codec_h264std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
+    //=== vulkan_video_codec_h264std_decode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
+    //=== vulkan_video_codec_h265std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
+    //=== vulkan_video_codec_vp9std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Level;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ReferenceName;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
+    //=== vulkan_video_codec_av1std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode;
+#endif
+
+    //===============
+    //=== STRUCTS ===
+    //===============
+
+#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
+    //=== vulkan_video_codec_h264std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
+    //=== vulkan_video_codec_h264std_decode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ )
+    //=== vulkan_video_codec_h264std_encode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
+    //=== vulkan_video_codec_h265std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
+    //=== vulkan_video_codec_h265std_decode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ )
+    //=== vulkan_video_codec_h265std_encode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
+    //=== vulkan_video_codec_vp9std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ )
+    //=== vulkan_video_codec_vp9std_decode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
+    //=== vulkan_video_codec_av1std ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ )
+    //=== vulkan_video_codec_av1std_decode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags;
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ )
+    //=== vulkan_video_codec_av1std_encode ===
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
+#endif
+
+  }  // namespace VULKAN_HPP_VIDEO_NAMESPACE
+}  // namespace VULKAN_HPP_NAMESPACE

include/vulkan/vulkan_wayland.h

@@ -2,7 +2,7 @@
 #define VULKAN_WAYLAND_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -36,17 +36,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance,
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
     VkInstance                                  instance,
     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
     VkPhysicalDevice                            physicalDevice,
     uint32_t                                    queueFamilyIndex,
     struct wl_display*                          display);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_win32.h

@@ -2,7 +2,7 @@
 #define VULKAN_WIN32_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -36,16 +36,20 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, c
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
     VkInstance                                  instance,
     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
     VkPhysicalDevice                            physicalDevice,
     uint32_t                                    queueFamilyIndex);
 #endif
+#endif
 
 
 // VK_KHR_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
@@ -85,17 +89,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, con
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
     VkDevice                                    device,
     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
     HANDLE*                                     pHandle);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
     VkDevice                                    device,
     VkExternalMemoryHandleTypeFlagBits          handleType,
     HANDLE                                      handle,
     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
 #endif
+#endif
 
 
 // VK_KHR_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
@@ -158,15 +166,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice devic
 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
     VkDevice                                    device,
     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
     VkDevice                                    device,
     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
     HANDLE*                                     pHandle);
 #endif
+#endif
 
 
 // VK_KHR_external_fence_win32 is a preprocessor guard. Do not pass it to API calls.
@@ -202,15 +214,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, c
 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
     VkDevice                                    device,
     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
     VkDevice                                    device,
     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
     HANDLE*                                     pHandle);
 #endif
+#endif
 
 
 // VK_NV_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
@@ -234,12 +250,14 @@ typedef struct VkExportMemoryWin32HandleInfoNV {
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
     VkDevice                                    device,
     VkDeviceMemory                              memory,
     VkExternalMemoryHandleTypeFlagsNV           handleType,
     HANDLE*                                     pHandle);
 #endif
+#endif
 
 
 // VK_NV_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
@@ -296,25 +314,33 @@ typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice d
 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
     VkPhysicalDevice                            physicalDevice,
     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
     uint32_t*                                   pPresentModeCount,
     VkPresentModeKHR*                           pPresentModes);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
     VkDevice                                    device,
     VkSwapchainKHR                              swapchain);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
     VkDevice                                    device,
     VkSwapchainKHR                              swapchain);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
     VkDevice                                    device,
     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
     VkDeviceGroupPresentModeFlagsKHR*           pModes);
 #endif
+#endif
 
 
 // VK_NV_acquire_winrt_display is a preprocessor guard. Do not pass it to API calls.
@@ -325,15 +351,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physi
 typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
     VkPhysicalDevice                            physicalDevice,
     VkDisplayKHR                                display);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
     VkPhysicalDevice                            physicalDevice,
     uint32_t                                    deviceRelativeId,
     VkDisplayKHR*                               pDisplay);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_xcb.h

@@ -2,7 +2,7 @@
 #define VULKAN_XCB_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -36,18 +36,22 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, con
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
     VkInstance                                  instance,
     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
     VkPhysicalDevice                            physicalDevice,
     uint32_t                                    queueFamilyIndex,
     xcb_connection_t*                           connection,
     xcb_visualid_t                              visual_id);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_xlib.h

@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -36,18 +36,22 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, co
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
     VkInstance                                  instance,
     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
     VkPhysicalDevice                            physicalDevice,
     uint32_t                                    queueFamilyIndex,
     Display*                                    dpy,
     VisualID                                    visualID);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

include/vulkan/vulkan_xlib_xrandr.h

@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_XRANDR_H_ 1
 
 /*
-** Copyright 2015-2023 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -27,17 +27,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physi
 typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
 
 #ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
     VkPhysicalDevice                            physicalDevice,
     Display*                                    dpy,
     VkDisplayKHR                                display);
+#endif
 
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
     VkPhysicalDevice                            physicalDevice,
     Display*                                    dpy,
     RROutput                                    rrOutput,
     VkDisplayKHR*                               pDisplay);
 #endif
+#endif
 
 #ifdef __cplusplus
 }

registry/vulkan_object.py

@@ -0,0 +1,586 @@
+#!/usr/bin/env python3 -i
+#
+# Copyright 2023-2025 The Khronos Group Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass, field
+from enum import IntFlag, Enum, auto
+
+@dataclass
+class FeatureRequirement:
+    """Each instance of FeatureRequirement is one part of the AND operation,
+       unless the struct/field are the same, then the depends are AND togethered"""
+    struct: str
+    field: str # Can have comma delimiter, which are expressed as OR
+    depends: (str | None) # ex) "VK_EXT_descriptor_indexing", "VK_VERSION_1_2+VkPhysicalDeviceVulkan12Features::descriptorIndexing"
+
+@dataclass
+class Extension:
+    """<extension>"""
+    name: str # ex) VK_KHR_SURFACE
+    nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME
+    specVersion: str # marco with string, ex) VK_KHR_SURFACE_SPEC_VERSION
+
+    # Only one will be True, the other is False
+    instance: bool
+    device: bool
+
+    depends: (str | None)
+    vendorTag: (str | None)  # ex) EXT, KHR, etc
+    platform: (str | None)   # ex) android
+    protect: (str | None)    # ex) VK_USE_PLATFORM_ANDROID_KHR
+    provisional: bool
+    promotedTo: (str | None) # ex) VK_VERSION_1_1
+    deprecatedBy: (str | None)
+    obsoletedBy: (str | None)
+    specialUse: list[str]
+    featureRequirement: list[FeatureRequirement]
+    ratified: bool
+
+    # These are here to allow for easy reverse lookups
+    # To prevent infinite recursion, other classes reference a string back to the Extension class
+    # Quotes allow us to forward declare the dataclass
+    handles:  list['Handle']  = field(default_factory=list, init=False)
+    commands: list['Command'] = field(default_factory=list, init=False)
+    structs:  list['Struct']  = field(default_factory=list, init=False)
+    enums:    list['Enum']    = field(default_factory=list, init=False)
+    bitmasks: list['Bitmask'] = field(default_factory=list, init=False)
+    flags: dict[str, list['Flags']] = field(default_factory=dict, init=False)
+    # Use the Enum name to see what fields are extended
+    enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
+    # Use the Bitmask name to see what flag bits are added to it
+    flagBits: dict[str, list['Flag']] = field(default_factory=dict, init=False)
+
+@dataclass
+class Version:
+    """
+    <feature> which represents a version
+    This will NEVER be Version 1.0, since having 'no version' is same as being 1.0
+    """
+    name: str       # ex) VK_VERSION_1_1
+    nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes)
+    nameApi: str    # ex) VK_API_VERSION_1_1
+
+    featureRequirement: list[FeatureRequirement]
+
+@dataclass
+class Legacy:
+    """<deprecate>
+    For historical reasons, the XML tag is "deprecate" but we decided in the WG to not use that as the public facing name
+    """
+    link: (str | None) # Spec URL Anchor - ex) legacy-dynamicrendering
+    version: (Version | None)
+    extensions: list[str]
+
+@dataclass
+class Handle:
+    """<type> which represents a dispatch handle"""
+    name: str # ex) VkBuffer
+    aliases: list[str] # ex) ['VkSamplerYcbcrConversionKHR']
+
+    type: str # ex) VK_OBJECT_TYPE_BUFFER
+    protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
+
+    parent: 'Handle' # Chain of parent handles, can be None
+
+    # Only one will be True, the other is False
+    instance: bool
+    device: bool
+
+    dispatchable: bool
+
+    extensions: list[str] # All extensions that enable the handle
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+class ExternSync(Enum):
+    NONE          = auto() # no externsync attribute
+    ALWAYS        = auto() # externsync="true"
+    MAYBE         = auto() # externsync="maybe"
+    SUBTYPE       = auto() # externsync="param->member"
+    SUBTYPE_MAYBE = auto() # externsync="maybe:param->member"
+
+@dataclass
+class Param:
+    """<command/param>"""
+    name: str # ex) pCreateInfo, pAllocator, pBuffer
+    alias: str
+
+    # the "base type" - will not preserve the 'const' or pointer info
+    # ex) void, uint32_t, VkFormat, VkBuffer, etc
+    type: str
+    # the "full type" - will be cDeclaration without the type name
+    # ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc
+    # For arrays, this will only display the type, fixedSizeArray can be used to get the length
+    fullType: str
+
+    noAutoValidity: bool
+
+    const: bool           # type contains 'const'
+    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
+    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
+    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
+    # Used to list how large an array of the type is
+    # ex) lineWidthRange is ['2']
+    # ex) memoryTypes is ['VK_MAX_MEMORY_TYPES']
+    # ex) VkTransformMatrixKHR:matrix is ['3', '4']
+    fixedSizeArray: list[str]
+
+    optional: bool
+    optionalPointer: bool # if type contains a pointer, is the pointer value optional
+
+    externSync: ExternSync
+    externSyncPointer: (str | None)  # if type contains a pointer (externSync is SUBTYPE*),
+                                     # only a specific member is externally synchronized.
+
+    # C string of member, example:
+    #   - const void* pNext
+    #   - VkFormat format
+    #   - VkStructureType sType
+    cDeclaration: str
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+class CommandScope(Enum):
+    NONE    = auto()
+    INSIDE  = auto()
+    OUTSIDE = auto()
+    BOTH    = auto()
+
+@dataclass
+class Command:
+    """<command>"""
+    name: str # ex) vkCmdDraw
+    alias: (str | None) # Because commands are interfaces into layers/drivers, we need all command alias
+    protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS'
+
+    extensions: list[str] # All extensions that enable the struct
+    version: (Version | None) # None if Version 1.0
+
+    returnType: str # ex) void, VkResult, etc
+
+    params: list[Param] # Each parameter of the command
+
+    # Only one will be True, the other is False
+    instance: bool
+    device: bool
+
+    tasks: list[str]        # ex) [ action, state, synchronization ]
+    queues: list[str]       # ex) [ VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT ]
+    allowNoQueues: bool     # VK_KHR_maintenance9 allows some calls to be done with zero queues
+    successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ]
+    errorCodes: list[str]   # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ]
+
+    # Shows support if command can be in a primary and/or secondary command buffer
+    primary: bool
+    secondary: bool
+
+    renderPass: CommandScope
+    videoCoding: CommandScope
+
+    implicitExternSyncParams: list[str]
+
+    legacy: (Legacy | None)
+
+    # C prototype string - ex:
+    # VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
+    #   const VkInstanceCreateInfo* pCreateInfo,
+    #   const VkAllocationCallbacks* pAllocator,
+    #   VkInstance* pInstance);
+    cPrototype: str
+
+    # function pointer typedef  - ex:
+    # typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)
+    #   (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+    cFunctionPointer: str
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Member:
+    """<member>"""
+    name: str # ex) sType, pNext, flags, size, usage
+
+    # the "base type" - will not preserve the 'const' or pointer info
+    # ex) void, uint32_t, VkFormat, VkBuffer, etc
+    type: str
+    # the "full type" - will be cDeclaration without the type name
+    # ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc
+    # For arrays, this will only display the type, fixedSizeArray can be used to get the length
+    fullType: str
+
+    noAutoValidity: bool
+    limitType: (str | None) # ex) 'max', 'bitmask', 'bits', 'min,mul'
+
+    const: bool           # type contains 'const'
+    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
+    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
+    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
+    # Used to list how large an array of the type is
+    # ex) lineWidthRange is ['2']
+    # ex) memoryTypes is ['VK_MAX_MEMORY_TYPES']
+    # ex) VkTransformMatrixKHR:matrix is ['3', '4']
+    fixedSizeArray: list[str]
+
+    optional: bool
+    optionalPointer: bool # if type contains a pointer, is the pointer value optional
+
+    externSync: ExternSync
+
+    # C string of member, example:
+    #   - const void* pNext
+    #   - VkFormat format
+    #   - VkStructureType sType
+    cDeclaration: str
+
+    bitFieldWidth: (int | None) # bit width (only for bit field struct members)
+
+    # Selector for the union, this type determines the used data type in the union
+    selector: (str | None)
+    # Valid selections for the union member
+    selection: list[str]
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Struct:
+    """<type category="struct"> or <type category="union">"""
+    name: str # ex) VkImageSubresource2
+    aliases: list[str] # ex) ['VkImageSubresource2KHR', 'VkImageSubresource2EXT']
+
+    extensions: list[str] # All extensions that enable the struct
+    version: (Version | None) # None if Version 1.0
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    members: list[Member]
+
+    union: bool # Unions are just a subset of a Structs
+    returnedOnly: bool
+
+    sType: (str | None) # ex) VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
+    allowDuplicate: bool # can have a pNext point to itself
+
+    # These use to be list['Struct'] but some circular loops occur and cause
+    # pydevd warnings and made debugging slow (30 seconds to index a Struct)
+    extends: list[str] # Struct names that this struct extends
+    extendedBy: list[str] # Struct names that can be extended by this struct
+
+    # This field is only set for enum definitions coming from Video Std headers
+    videoStdHeader: (str | None) = None
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class EnumField:
+    """<enum> of type enum"""
+    name: str # ex) VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT
+    aliases: list[str] # ex) ['VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT']
+
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    negative: bool # True if negative values are allowed (ex. VkResult)
+    value: int
+    valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004")
+
+    # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
+    extensions: list[str] # None if part of 1.0 core
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Enum:
+    """<enums> of type enum"""
+    name: str # ex) VkLineRasterizationMode
+    aliases: list[str] # ex) ['VkLineRasterizationModeKHR', 'VkLineRasterizationModeEXT']
+
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    bitWidth: int # 32 or 64 (currently all are 32, but field is to match with Bitmask)
+    returnedOnly: bool
+
+    fields: list[EnumField]
+
+    extensions: list[str] # None if part of 1.0 core
+    # Unique list of all extension that are involved in 'fields' (superset of 'extensions')
+    fieldExtensions: list[str]
+
+    # This field is only set for enum definitions coming from Video Std headers
+    videoStdHeader: (str | None) = None
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Flag:
+    """<enum> of type bitmask"""
+    name: str # ex) VK_ACCESS_2_SHADER_READ_BIT
+    aliases: str # ex) ['VK_ACCESS_2_SHADER_READ_BIT_KHR']
+
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    value: int
+    valueStr: str # value as shown in spec (ex. 0x00000000", "0x00000004", "0x0000000F", "0x800000000ULL")
+    multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
+    zero: bool     # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)
+
+    # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
+    extensions: list[str] # None if part of 1.0 core
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Bitmask:
+    """<enums> of type bitmask"""
+    name: str     # ex) VkAccessFlagBits2
+    aliases: list[str] # ex) ['VkAccessFlagBits2KHR']
+
+    flagName: str # ex) VkAccessFlags2
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    bitWidth: int # 32 or 64
+    returnedOnly: bool
+
+    flags: list[Flag]
+
+    extensions: list[str] # None if part of 1.0 core
+    # Unique list of all extension that are involved in 'flag' (superset of 'extensions')
+    flagExtensions: list[str]
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Flags:
+    """<type> defining flags types"""
+    name: str # ex) VkAccessFlags2
+    aliases: list[str] # ex) [`VkAccessFlags2KHR`]
+
+    bitmaskName: (str | None) # ex) VkAccessFlagBits2
+    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
+
+    baseFlagsType: str # ex) VkFlags
+    bitWidth: int # 32 or 64
+    returnedOnly: bool
+
+    extensions: list[str] # None if part of 1.0 core
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class Constant:
+    name: str # ex) VK_UUID_SIZE
+    type: str # ex) uint32_t, float
+    value: (int | float)
+    valueStr: str # value as shown in spec (ex. "(~0U)", "256U", etc)
+
+    # This field is only set for enum definitions coming from Video Std headers
+    videoStdHeader: (str | None) = None
+
+@dataclass
+class FormatComponent:
+    """<format/component>"""
+    type: str # ex) R, G, B, A, D, S, etc
+    bits: str # will be an INT or 'compressed'
+    numericFormat: str # ex) UNORM, SINT, etc
+    planeIndex: (int | None) # None if no planeIndex in format
+
+@dataclass
+class FormatPlane:
+    """<format/plane>"""
+    index: int
+    widthDivisor: int
+    heightDivisor: int
+    compatible: str
+
+@dataclass
+class Format:
+    """<format>"""
+    name: str
+    className: str
+    blockSize: int
+    texelsPerBlock: int
+    blockExtent: list[str]
+    packed: (int | None) # None == not-packed
+    chroma: (str | None)
+    compressed: (str | None)
+    components: list[FormatComponent] # <format/component>
+    planes: list[FormatPlane]  # <format/plane>
+    spirvImageFormat: (str | None)
+
+@dataclass
+class SyncSupport:
+    """<syncsupport>"""
+    queues: list[str]  # ex) [ VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT ]
+    stages: list[Flag] # VkPipelineStageFlagBits2
+    max: bool # If this supports max values
+
+@dataclass
+class SyncEquivalent:
+    """<syncequivalent>"""
+    stages: list[Flag] # VkPipelineStageFlagBits2
+    accesses: list[Flag] # VkAccessFlagBits2
+    max: bool # If this equivalent to everything
+
+@dataclass
+class SyncStage:
+    """<syncstage>"""
+    flag: Flag # VkPipelineStageFlagBits2
+    support: SyncSupport
+    equivalent: SyncEquivalent
+
+@dataclass
+class SyncAccess:
+    """<syncaccess>"""
+    flag: Flag # VkAccessFlagBits2
+    support: SyncSupport
+    equivalent: SyncEquivalent
+
+@dataclass
+class SyncPipelineStage:
+    """<syncpipelinestage>"""
+    order: (str | None)
+    before: (str | None)
+    after: (str | None)
+    value: str
+
+@dataclass
+class SyncPipeline:
+    """<syncpipeline>"""
+    name: str
+    depends: list[str]
+    stages: list[SyncPipelineStage]
+
+@dataclass
+class SpirvEnables:
+    """What is needed to enable the SPIR-V element"""
+    version: (str | None)
+    extension: (str | None)
+    struct: (str | None)
+    feature: (str | None)
+    requires: (str | None)
+    property: (str | None)
+    member: (str | None)
+    value: (str | None)
+
+@dataclass
+class Spirv:
+    """<spirvextension> and <spirvcapability>"""
+    name: str
+    # Only one will be True, the other is False
+    extension: bool
+    capability: bool
+    enable: list[SpirvEnables]
+
+@dataclass
+class VideoRequiredCapabilities:
+    """<videorequirecapabilities>"""
+    struct: str     # ex) VkVideoEncodeCapabilitiesKHR
+    member: str     # ex) flags
+    value: str      # ex) VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR
+                    # may contain XML boolean expressions ("+" means AND, "," means OR)
+
+@dataclass
+class VideoFormat:
+    """<videoformat>"""
+    name: str       # ex) Decode Output
+    usage: str      # ex) VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR
+                    # may contain XML boolean expressions ("+" means AND, "," means OR)
+
+    requiredCaps: list[VideoRequiredCapabilities]
+    properties: dict[str, str]
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class VideoProfileMember:
+    """<videoprofilemember> and <videoprofile>"""
+    name: str
+    # Video profile struct member (value attribute of <videoprofile>) value as key,
+    # profile name substring (name attribute of <videoprofile>) as value
+    values: dict[str, str]
+
+@dataclass
+class VideoProfiles:
+    """<videoprofiles>"""
+    name: str
+    members: dict[str, VideoProfileMember]
+
+@dataclass
+class VideoCodec:
+    """<videocodec>"""
+    name: str   # ex) H.264 Decode
+    value: (str | None) # If no video codec operation flag bit is associated with the codec
+                        # then it is a codec category (e.g. decode, encode), not a specific codec
+
+    profiles: dict[str, VideoProfiles]
+    capabilities: dict[str, str]
+    formats: dict[str, VideoFormat]
+
+    def __lt__(self, other):
+        return self.name < other.name
+
+@dataclass
+class VideoStdHeader:
+    """<extension> in video.xml"""
+    name: str # ex) vulkan_video_codec_h264std_decode
+    version: (str | None)   # ex) VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0
+                            # None if it is a shared common Video Std header
+
+    headerFile: str # ex) vk_video/vulkan_video_codec_h264std_decode.h
+
+    # Other Video Std headers that this one depends on
+    depends: list[str]
+
+@dataclass
+class VideoStd:
+    headers: dict[str, VideoStdHeader] = field(default_factory=dict, init=False)
+
+    enums: dict[str, Enum]           = field(default_factory=dict, init=False)
+    structs: dict[str, Struct]       = field(default_factory=dict, init=False)
+    constants: dict[str, Constant]   = field(default_factory=dict, init=False)
+
+# This is the global Vulkan Object that holds all the information from parsing the XML
+# This class is designed so all generator scripts can use this to obtain data
+@dataclass
+class VulkanObject():
+    headerVersion:         int = 0  # value of VK_HEADER_VERSION (ex. 345)
+    headerVersionComplete: str = '' # value of VK_HEADER_VERSION_COMPLETE (ex. '1.2.345' )
+
+    extensions: dict[str, Extension] = field(default_factory=dict, init=False)
+    versions:   dict[str, Version]   = field(default_factory=dict, init=False)
+
+    handles:   dict[str, Handle]     = field(default_factory=dict, init=False)
+    commands:  dict[str, Command]    = field(default_factory=dict, init=False)
+    structs:   dict[str, Struct]     = field(default_factory=dict, init=False)
+    enums:     dict[str, Enum]       = field(default_factory=dict, init=False)
+    bitmasks:  dict[str, Bitmask]    = field(default_factory=dict, init=False)
+    flags:     dict[str, Flags]      = field(default_factory=dict, init=False)
+    constants: dict[str, Constant]   = field(default_factory=dict, init=False)
+    formats:   dict[str, Format]     = field(default_factory=dict, init=False)
+
+    syncStage:    list[SyncStage]    = field(default_factory=list, init=False)
+    syncAccess:   list[SyncAccess]   = field(default_factory=list, init=False)
+    syncPipeline: list[SyncPipeline] = field(default_factory=list, init=False)
+
+    spirv: list[Spirv]               = field(default_factory=list, init=False)
+
+    # ex) [ xlib : VK_USE_PLATFORM_XLIB_KHR ]
+    platforms: dict[str, str]        = field(default_factory=dict, init=False)
+    # list of all vendor Suffix names (KHR, EXT, etc. )
+    vendorTags: list[str]            = field(default_factory=list, init=False)
+
+    # Video codec information from the vk.xml
+    videoCodecs: dict[str, VideoCodec] = field(default_factory=dict, init=False)
+
+    # Video Std header information from the video.xml
+    videoStd: (VideoStd | None) = None

tests/add_subdirectory/CMakeLists.txt

@@ -1,30 +0,0 @@
-# ~~~
-# Copyright 2022-2023 The Khronos Group Inc.
-# Copyright 2022-2023 Valve Corporation
-# Copyright 2022-2023 LunarG, Inc.
-#
-# SPDX-License-Identifier: Apache-2.0
-# ~~~
-cmake_minimum_required(VERSION 3.14.2)
-
-project(TEST_VULKAN_HEADERS_ADD_SUBDIRECTORY_SUPPORT LANGUAGES C)
-
-add_subdirectory(../../ ${CMAKE_CURRENT_BINARY_DIR}/headers)
-
-if (NOT TARGET Vulkan::Headers)
-    message(FATAL_ERROR "Vulkan::Headers target not defined")
-endif()
-
-# Consuming vulkan-headers via add_subdirectory should NOT add installation code to the parent CMake project.
-if (DEFINED CMAKE_INSTALL_INCLUDEDIR)
-    message(FATAL_ERROR "CMAKE_INSTALL_INCLUDEDIR was defined!")
-endif()
-
-add_library(foobar STATIC)
-
-target_link_libraries(foobar PRIVATE Vulkan::Headers)
-
-target_sources(foobar PRIVATE
-    ../vk_icd.c
-    ../vk_layer.c
-)

tests/integration/CMakeLists.txt

@@ -0,0 +1,89 @@
+# ~~~
+# Copyright 2022-2023 The Khronos Group Inc.
+# Copyright 2022-2023 Valve Corporation
+# Copyright 2022-2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+# ~~~
+cmake_minimum_required(VERSION 3.22.1)
+
+project(API LANGUAGES C CXX)
+
+if (FIND_PACKAGE_TESTING)
+    find_package(VulkanHeaders REQUIRED CONFIG)
+else()
+    add_subdirectory(../../ ${CMAKE_CURRENT_BINARY_DIR}/headers)
+endif()
+
+if (NOT TARGET Vulkan::Headers)
+    message(FATAL_ERROR "Vulkan::Headers target not defined")
+endif()
+if (NOT TARGET Vulkan::HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
+    message(FATAL_ERROR "Vulkan::HppModule target not defined")
+endif()
+
+if (FIND_PACKAGE_TESTING)
+    if (NOT DEFINED VulkanHeaders_VERSION)
+        message(FATAL_ERROR "VulkanHeaders_VERSION not defined!")
+    endif()
+    message(STATUS "VulkanHeaders_VERSION = ${VulkanHeaders_VERSION}")
+else()
+    # Consuming vulkan-headers via add_subdirectory should NOT add installation code to the parent CMake project.
+    if (DEFINED CMAKE_INSTALL_INCLUDEDIR)
+        message(FATAL_ERROR "CMAKE_INSTALL_INCLUDEDIR was defined!")
+    endif()
+
+    # NOTE: Some users may not be using the namespace target.
+    # Don't accidentally break them unless we have to.
+    if (NOT TARGET Vulkan-Headers)
+        message(FATAL_ERROR "Backcompat for Vulkan-Headers target broken!")
+    endif()
+    if (NOT TARGET Vulkan-HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
+        message(FATAL_ERROR "Backcompat for Vulkan-HppModule target broken!")
+    endif()
+endif()
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS OFF)
+
+if(${CMAKE_C_COMPILER_ID} MATCHES "(GNU|Clang)")
+    add_compile_options(
+        -Wpedantic
+        -Wall
+        -Wextra
+        -Werror
+    )
+endif()
+
+if (MSVC)
+    add_compile_options(
+        /W4
+        /permissive-
+        /WX
+    )
+endif()
+
+# Test the non-API headers provided by this repo
+# NOTE: For us testing just means that these header files compile
+# with reasonable warnings.
+
+# vk_icd.h
+add_library(vk_icd MODULE ../vk_icd.c)
+target_link_libraries(vk_icd PRIVATE Vulkan::Headers)
+
+# vk_layer.h
+add_library(vk_layer MODULE ../vk_layer.c)
+target_link_libraries(vk_layer PRIVATE Vulkan::Headers)
+
+# vulkan.hpp
+add_library(vk_hpp MODULE ../vk_hpp.cpp)
+target_compile_features(vk_hpp PUBLIC cxx_std_11)
+target_link_libraries(vk_hpp PRIVATE Vulkan::Headers)
+
+# vulkan.cppm
+if (VULKAN_HEADERS_ENABLE_MODULE)
+    add_library(vk_hpp_module MODULE ../vk_hpp_module.cpp)
+    set_target_properties(vk_hpp_module PROPERTIES CXX_SCAN_FOR_MODULES ON)
+    target_link_libraries(vk_hpp_module PRIVATE Vulkan::HppModule)
+endif()

tests/vk_hpp.cpp

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2025 The Khronos Group Inc.
+ * Copyright 2025 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <vulkan/vulkan.hpp>
+
+int test_version()
+{
+    return static_cast<int>(vk::makeApiVersion(1, 0, 0, 0));
+}

tests/vk_hpp_module.cpp

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2025 The Khronos Group Inc.
+ * Copyright 2025 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import vulkan_hpp;
+
+int test_version()
+{
+    return static_cast<int>(vk::makeApiVersion(1, 0, 0, 0));
+}