working on python bindings

Automated changes by
[create-pull-request](https://github.com/peter-evans/create-pull-request)
GitHub action

.github/workflows/tests.yml

@@ -0,0 +1,78 @@
+name: Unit tests
+
+on:
+  pull_request:
+  push:
+    paths-ignore:
+      - '.gitignore'
+      - 'LICENSE'
+      - 'README.md'
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04]
+        arch: [x86_64]
+
+    runs-on: ${{ matrix.os }}
+    if: "!contains(github.event.head_commit.message, 'ci skip')"
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - uses: NcStudios/VulkanCI@v1.0
+
+    - name: Install system dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get -y install mesa-common-dev clang libsdl2-2.0-0 libsdl2-dev build-essential libvulkan-dev
+
+    # Build the lib
+    - name: Build MacroLibX
+      run: make -j DEBUG=true
+
+    # Force xmake to a specific folder (for cache)
+    - name: Set xmake env
+      run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" >> $GITHUB_ENV
+
+    # Install xmake
+    - name: Setup xmake
+      if: ${{ matrix.confs.plat != 'mingw' }}
+      uses: xmake-io/github-action-setup-xmake@v1
+      with:
+        xmake-version: latest
+        actions-cache-folder: .xmake-cache-W${{ steps.cache_key.outputs.key }}
+
+    # Update xmake repository (in order to have the file that will be cached)
+    - name: Update xmake repository
+      run: xmake repo --update
+
+    # Fetch xmake dephash
+    - name: Retrieve dependencies hash
+      id: dep_hash
+      run: echo "hash=$(xmake l utils.ci.packageskey)" >> $GITHUB_OUTPUT
+
+    - name: Install unit tester
+      run: git clone https://github.com/seekrs/MacroUnitTest.git ../MacroUnitTest
+
+    # Setup compilation mode and install project dependencies
+    - name: Configure xmake and install dependencies
+      run: |
+        cd ../MacroUnitTest
+        xmake config --toolchain=clang --ccache=n --yes
+
+    # Save dependencies
+    - name: Save cached xmake dependencies
+      if: ${{ !steps.restore-depcache.outputs.cache-hit }}
+      uses: actions/cache/save@v4
+      with:
+        path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
+        key: ${{ steps.restore-depcache.outputs.cache-primary-key }}
+
+    - name: Build and run unit tester
+      run: |
+        cd ../MacroUnitTest
+        xmake run MacroUnitTest --headless --path="${{ runner.workspace }}/MacroLibX/libmlx.so"

.gitignore

@@ -23,3 +23,5 @@
 objs/
 build/
 example/Test
+macrolibpy/__pycache__
+example/__pycache__

README.md

@@ -8,6 +8,9 @@
     <div align="center">
         <a href="https://github.com/seekrs/MacroLibX/actions/workflows/windows.yml"><img src="https://github.com/seekrs/MacroLibX/actions/workflows/windows.yml/badge.svg"></a>
     </div>
+    <div align="center">
+        <a href="https://github.com/seekrs/MacroLibX/actions/workflows/tests.yml"><img src="https://github.com/seekrs/MacroLibX/actions/workflows/tests.yml/badge.svg"></a>
+    </div>
 </div>
 
 ###### MacroLibX, a rewrite of 42 School's MiniLibX using SDL2 and Vulkan. 

example/main.py

@@ -0,0 +1,85 @@
+import macrolibpy as mlpy
+import pathlib
+import os
+import math
+
+current_path = pathlib.Path(__file__).parent.resolve()
+
+mlx = mlpy.Context.create()
+win = mlx.new_window(400, 400, "My window")
+mlx.set_fps_goal(60)
+logo_png = mlx.new_image_from_file(os.path.join(current_path, "42_logo.png"))[0]
+logo_bmp = mlx.new_image_from_file(os.path.join(current_path, "42_logo.bmp"))[0]
+logo_jpg = mlx.new_image_from_file(os.path.join(current_path, "42_logo.jpg"))[0]
+
+win.pixel_put(200, 10, 0xFF0FFFF)
+win.put_image(logo_png, 0, 0)
+
+mlx.set_font_scale(os.path.join(current_path, "font.ttf"), 16.0)
+win.string_put(20, 20, 0x0020FFFF, "that text will disappear")
+
+custom_img = mlx.new_image(100, 100)
+i, j, k = 0, 0, 0
+while i < (100 * 100) * 4:
+    if j >= 100:
+        j = 0
+        k += 1
+    if i < 10000 or i > 20000:
+        custom_img.set_pixel(j, k, (k << 24) | (j << 16) | (i << 8) | 0x99)
+    i += 4
+    j += 1
+
+def onevent(ev):
+    if ev == 0:
+        mlx.loop_end()
+
+THRESHOLD = 200
+CIRCLE_RADIUS = 50
+CIRCLE_DIAMETER = CIRCLE_RADIUS + CIRCLE_RADIUS
+def onupdate():
+    if onupdate.i > THRESHOLD:
+        win.clear(0x334D4DFF)
+        win.put_transformed_image(logo_bmp, 220, 40, 0.5, 0.5, onupdate.i)
+
+    if onupdate.i >= THRESHOLD + THRESHOLD / 4:
+        mlx.set_font_scale("default", 16.0)
+    else:
+        mlx.set_font_scale("default", 6.0)
+
+    win.string_put(160, 120, 0xFF2066FF, "this text should be behind")
+    win.put_image(logo_png, 100, 100)
+    win.put_image(custom_img, 150, 60)
+
+    mlx.set_font("default")
+    win.string_put(20, 50, 0xFFFFFFFF, "that's a text")
+
+    color = 0
+    for j in range(0, 400):
+        win.pixel_put(j, j, 0x0000FFFF + (color << 24))
+        win.pixel_put(399 - j, j, 0x0000FFFF)
+        color += (color < 255)
+
+    if onupdate.i < THRESHOLD:
+        win.put_transformed_image(logo_jpg, 210, 150, 0.5, 2.0, 0.0)
+    else:
+        win.put_transformed_image(logo_jpg, 210, 150, abs(math.sin(onupdate.i / 100.0)), abs(math.cos(onupdate.i / 100.0) * 2.0), 0.0)
+
+    mlx.set_font_scale("default", 8.0)
+    win.string_put(210, 175, 0xFFAF2BFF, "hidden")
+
+    win.pixel_put_region(200, 170, CIRCLE_DIAMETER, CIRCLE_DIAMETER, onupdate.pixels_circle)
+
+    onupdate.i += 1
+onupdate.i = 0
+onupdate.pixels_circle = [pixel for pixel in range(0, CIRCLE_DIAMETER * CIRCLE_DIAMETER)]
+
+i = 0
+for j in range(0, CIRCLE_DIAMETER):
+    for k in range(0, CIRCLE_DIAMETER):
+        if((CIRCLE_RADIUS - j) * (CIRCLE_RADIUS - j) + (CIRCLE_RADIUS - k) * (CIRCLE_RADIUS - k) < CIRCLE_RADIUS * CIRCLE_RADIUS):
+            onupdate.pixels_circle[i] = 0xA10000FF + ((j * k * i) << 8)
+        i += 1
+
+win.on_event(mlpy.EventType.WINDOW_EVENT, onevent)
+mlx.add_loop_hook(onupdate)
+mlx.loop()

macrolibpy/__init__.py

@@ -0,0 +1,368 @@
+"""
+macrolibpy — thin, Pythonic bindings over MacroLibX.
+"""
+
+from __future__ import annotations
+from enum import IntEnum
+from typing import Callable, Optional, Any, List
+import os, sys
+from cffi import FFI
+import pathlib
+
+__all__ = ["Context", "Window", "Image", "Event"]
+
+ffi = FFI()
+
+# NOTE: This is a curated declaration set focused on the core API
+ffi.cdef(
+    r"""
+    typedef unsigned char uint8_t;
+    typedef unsigned int uint32_t;
+
+    typedef void (*mlx_function)(void);
+    typedef struct mlx_context_handler* mlx_context;
+    typedef struct mlx_window_handler* mlx_window;
+    typedef struct mlx_image_handler* mlx_image;
+
+    typedef struct mlx_color
+    {
+        uint32_t rgba;
+    } mlx_color;
+
+    typedef enum mlx_event_type
+    {
+        MLX_KEYDOWN = 0,
+        MLX_KEYUP = 1,
+        MLX_MOUSEDOWN = 2,
+        MLX_MOUSEUP = 3,
+        MLX_MOUSEWHEEL = 4,
+        MLX_WINDOW_EVENT = 5
+    } mlx_event_type;
+
+    typedef struct mlx_window_create_info
+    {
+        mlx_image render_target;
+        const char* title;
+        int width;
+        int height;
+        _Bool is_fullscreen;
+        _Bool is_resizable;
+    } mlx_window_create_info;
+
+    mlx_context mlx_init();
+    void mlx_set_fps_goal(mlx_context mlx, int fps);
+    void mlx_destroy_context(mlx_context mlx);
+    mlx_window mlx_new_window(mlx_context mlx, const mlx_window_create_info* info);
+    void mlx_destroy_window(mlx_context mlx, mlx_window win);
+    void mlx_set_window_position(mlx_context mlx, mlx_window win, int x, int y);
+    void mlx_set_window_size(mlx_context mlx, mlx_window win, int width, int height);
+    void mlx_set_window_title(mlx_context mlx, mlx_window win, const char* title);
+    void mlx_set_window_fullscreen(mlx_context mlx, mlx_window win, _Bool enable);
+    void mlx_get_window_position(mlx_context mlx, mlx_window win, int* x, int* y);
+    void mlx_get_window_size(mlx_context mlx, mlx_window win, int* x, int* y);
+    void mlx_clear_window(mlx_context mlx, mlx_window win, mlx_color color);
+    void mlx_get_screen_size(mlx_context mlx, mlx_window win, int* w, int* h);
+    void mlx_add_loop_hook(mlx_context mlx, void(*f)(void*), void* param);
+    void mlx_loop(mlx_context mlx);
+    void mlx_loop_end(mlx_context mlx);
+    void mlx_mouse_show(mlx_context mlx);
+    void mlx_mouse_hide(mlx_context mlx);
+    void mlx_mouse_move(mlx_context mlx, mlx_window win, int x, int y);
+    void mlx_mouse_get_pos(mlx_context mlx, int* x, int* y);
+    void mlx_on_event(mlx_context mlx, mlx_window win, mlx_event_type event, void(*f)(int, void*), void* param);
+    void mlx_pixel_put(mlx_context mlx, mlx_window win, int x, int y, mlx_color color);
+    mlx_image mlx_new_image(mlx_context mlx, int width, int height);
+    mlx_image mlx_new_image_from_file(mlx_context mlx, char* filename, int* width, int* height);
+    void mlx_destroy_image(mlx_context mlx, mlx_image image);
+    mlx_color mlx_get_image_pixel(mlx_context mlx, mlx_image image, int x, int y);
+    void mlx_set_image_pixel(mlx_context mlx, mlx_image image, int x, int y, mlx_color color);
+    void mlx_put_image_to_window(mlx_context mlx, mlx_window win, mlx_image image, int x, int y);
+    void mlx_string_put(mlx_context mlx, mlx_window win, int x, int y, mlx_color color, char* str);
+    void mlx_set_font(mlx_context mlx, char* filepath);
+    void mlx_set_font_scale(mlx_context mlx, char* filepath, float scale);
+
+    void mlx_set_window_max_size(mlx_context mlx, mlx_window win, int x, int y);
+    void mlx_set_window_min_size(mlx_context mlx, mlx_window win, int x, int y);
+    void mlx_maximise_window(mlx_context mlx, mlx_window win);
+    void mlx_minimize_window(mlx_context mlx, mlx_window win);
+    void mlx_restore_window(mlx_context mlx, mlx_window win);
+    void mlx_pixel_put_array(mlx_context mlx, mlx_window win, int x, int y, mlx_color* pixels, size_t pixels_number);
+    void mlx_pixel_put_region(mlx_context mlx, mlx_window win, int x, int y, int w, int h, mlx_color* pixels);
+    void mlx_get_image_region(mlx_context mlx, mlx_image image, int x, int y, int w, int h, mlx_color* dst);
+    void mlx_set_image_region(mlx_context mlx, mlx_image image, int x, int y, int w, int h, mlx_color* pixels);
+    void mlx_put_transformed_image_to_window(mlx_context mlx, mlx_window win, mlx_image image, int x, int y, float scale_x, float scale_y, float angle);
+    """
+)
+
+def _candidateLibNames() -> List[str]:
+    if sys.platform.startswith("linux"):
+        return ["libmlx.so"]
+    if sys.platform == "darwin":
+        return ["libmlx.dylib"]
+    if sys.platform.startswith("win"):
+        # depending on build system, either of these may exist
+        return ["mlx.dll", "libmlx.dll"]
+    return []
+
+def _candidateSdl2Names() -> List[str]:
+    if sys.platform.startswith("linux"):
+        # Try common SONAMEs (distro dependent)
+        return ["libSDL2-2.0.so.0", "libSDL2.so.0", "libSDL2.so"]
+    if sys.platform == "darwin":
+        return ["libSDL2-2.0.0.dylib", "libSDL2.dylib"]
+    if sys.platform.startswith("win"):
+        return ["SDL2.dll"]
+    return []
+
+def _loadLibrary(candidates: List[str]):
+    last_err: Optional[BaseException] = None
+    RTLD_NOW = 2
+    RTLD_GLOBAL = 0x100
+    for path in candidates:
+        try:
+            return ffi.dlopen(path, RTLD_NOW | RTLD_GLOBAL)
+        except OSError as e:
+            last_err = e
+    raise OSError(
+        f"Could not load library:\n"
+        f"\tTried: {candidates}.\n"
+        f"\tLast error: {last_err}"
+    )
+
+def _dlopenMlx():
+    _loadLibrary(_candidateSdl2Names())
+    candidates: List[str] = []
+    for name in _candidateLibNames():
+        candidates.append(os.path.join(pathlib.Path(__file__).parent.parent.resolve(), name))
+    return _loadLibrary(candidates)
+
+lib = _dlopenMlx()
+
+class EventType(IntEnum):
+    KEYDOWN = 0
+    KEYUP = 1
+    MOUSEDOWN = 2
+    MOUSEUP = 3
+    MOUSEWHEEL = 4
+    WINDOW_EVENT = 5
+
+class MlxError(RuntimeError):
+    pass
+
+# Keep Python references to cffi callbacks alive
+_alive_callbacks: List[Any] = []
+
+def _makeLoopCallback(pyfunc: Callable[[], None]):
+    @ffi.callback("void(void*)")
+    def cfunc(userdata):
+        pyfunc()
+    _alive_callbacks.append(cfunc)
+    return cfunc
+
+def _makeEventCallback(pyfunc: Callable[[int], None]):
+    @ffi.callback("void(int, void*)")
+    def cfunc(event, userdata):
+        pyfunc(int(event))
+    _alive_callbacks.append(cfunc)
+    return cfunc
+
+def _rgbaToColor(rgba: int):
+    c = ffi.new("mlx_color*")
+    c[0].rgba = int(rgba) & 0xFFFFFFFF
+    return c[0]
+
+class Context:
+    __slots__ = ("_ctx",)
+
+    def __init__(self, _ptr) -> None:
+        self._ctx = _ptr
+
+    @classmethod
+    def create(cls) -> "Context":
+        ctx = lib.mlx_init()
+        if ctx == ffi.NULL:
+            raise MlxError("mlx_init failed")
+        return cls(ctx)
+
+    def set_fps_goal(self, fps: int) -> None:
+        lib.mlx_set_fps_goal(self._ctx, int(fps))
+
+    def add_loop_hook(self, fn: Callable[[], None]) -> None:
+        lib.mlx_add_loop_hook(self._ctx, _makeLoopCallback(fn), ffi.NULL)
+
+    def new_window(
+        self,
+        width: int,
+        height: int,
+        title: str,
+        resizable: bool = True,
+        fullscreen: bool = False,
+    ) -> "Window":
+        ffi_title = ffi.new("char[]", title.encode('ascii', 'replace'))
+
+        info = ffi.new("mlx_window_create_info*")
+        info.render_target = ffi.NULL
+        info.title = ffi_title
+        info.width = int(width)
+        info.height = int(height)
+        info.is_fullscreen = bool(fullscreen)
+        info.is_resizable = bool(resizable)
+        win = lib.mlx_new_window(self._ctx, info)
+        if win == ffi.NULL:
+            raise MlxError("mlx_new_window failed")
+        return Window(self, win)
+
+    def new_image(self, width: int, height: int) -> "Image":
+        img = lib.mlx_new_image(self._ctx, int(width), int(height))
+        if img == ffi.NULL:
+            raise MlxError("mlx_new_image failed")
+        return Image(self, img)
+
+    def new_image_from_file(self, path: str) -> Tuple["Image", int, int]:
+        w = ffi.new("int[]", 1);
+        h = ffi.new("int[]", 1);
+        ffi_path = ffi.new("char[]", path.encode('ascii'))
+        img = lib.mlx_new_image_from_file(self._ctx, ffi_path, w, h)
+        if img == ffi.NULL:
+            raise MlxError("mlx_new_image failed")
+        return (Image(self, img), w, h)
+
+    def loop(self) -> None:
+        lib.mlx_loop(self._ctx)
+
+    def loop_end(self) -> None:
+        lib.mlx_loop_end(self._ctx)
+
+    def destroy(self) -> None:
+        if getattr(self, "_ctx", None):
+            lib.mlx_destroy_context(self._ctx)
+            self._ctx = ffi.NULL
+
+    def mouse_show(self) -> None:
+        lib.mlx_mouse_show(self._ctx)
+
+    def mouse_hide(self) -> None:
+        lib.mlx_mouse_hide(self._ctx)
+
+    def mouse_move(self, x: int, y: int) -> None:
+        lib.mlx_mouse_move(self._ctx, int(x), int(y))
+
+    def get_mouse_position(self) -> Tuple[int, int]:
+        x = ffi.new("int[]", 1);
+        y = ffi.new("int[]", 1);
+        lib.mlx_mouse_get_pos(self._ctx, x, y)
+        return (x[0], y[0])
+
+    def set_font(self, path: str) -> None:
+        ffi_path = ffi.new("char[]", path.encode('ascii'))
+        lib.mlx_set_font(self._ctx, ffi_path)
+
+    def set_font_scale(self, path: str, scale: float) -> None:
+        ffi_path = ffi.new("char[]", path.encode('ascii'))
+        lib.mlx_set_font_scale(self._ctx, ffi_path, float(scale))
+
+    def __del__(self):
+        try:
+            self.destroy()
+        except Exception:
+            pass
+
+class Window:
+    __slots__ = ("_ctx", "_win")
+
+    def __init__(self, ctx: Context, win) -> None:
+        self._ctx = ctx
+        self._win = win
+
+    def set_title(self, title: str) -> None:
+        ffi_title = ffi.new("char[]", title.encode('ascii', 'replace'))
+        lib.mlx_set_window_title(self._ctx._ctx, self._win, ffi_title)
+
+    def set_position(self, x: int, y: int) -> None:
+        lib.mlx_set_window_position(self._ctx._ctx, self._win, int(x), int(y))
+
+    def set_size(self, w: int, h: int) -> None:
+        lib.mlx_set_window_size(self._ctx._ctx, self._win, int(w), int(h))
+
+    def set_fullscreen(self, enable: bool) -> None:
+        lib.mlx_set_window_fullscreen(self._ctx._ctx, self._win, bool(enable))
+
+    def get_position(self) -> Tuple[int, int]:
+        x = ffi.new("int[]", 1);
+        y = ffi.new("int[]", 1);
+        lib.mlx_get_window_position(self._ctx._ctx, self._win, x, y)
+        return (x[0], y[0])
+
+    def get_size(self) -> Tuple[int, int]:
+        w = ffi.new("int[]", 1);
+        h = ffi.new("int[]", 1);
+        lib.mlx_get_window_size(self._ctx._ctx, self._win, w, h)
+        return (w[0], h[0])
+
+    def get_screen_size(self) -> Tuple[int, int]:
+        w = ffi.new("int[]", 1);
+        h = ffi.new("int[]", 1);
+        lib.mlx_get_screen_size(self._ctx._ctx, self._win, w, h)
+        return (w[0], h[0])
+
+    def clear(self, rgba: int = 0) -> None:
+        lib.mlx_clear_window(self._ctx._ctx, self._win, _rgbaToColor(rgba))
+
+    def pixel_put(self, x: int, y: int, rgba: int) -> None:
+        lib.mlx_pixel_put(self._ctx._ctx, self._win, int(x), int(y), _rgbaToColor(rgba))
+
+    def pixel_put_array(self, x: int, y: int, rgba: list[int]) -> None:
+        ffi_pixels = ffi.new("mlx_color[]", [_rgbaToColor(pixel) for pixel in rgba])
+        lib.mlx_pixel_put_array(self._ctx._ctx, self._win, int(x), int(y), ffi_pixels, int(rgba.len()))
+
+    def pixel_put_region(self, x: int, y: int, w: int, h: int, rgba: list[int]) -> None:
+        ffi_pixels = ffi.new("mlx_color[]", [_rgbaToColor(pixel) for pixel in rgba])
+        lib.mlx_pixel_put_region(self._ctx._ctx, self._win, int(x), int(y), int(w), int(h), ffi_pixels)
+
+    def put_image(self, image: "Image", x: int, y: int) -> None:
+        lib.mlx_put_image_to_window(self._ctx._ctx, self._win, image._img, int(x), int(y))
+
+    def put_transformed_image(self, image: "Image", x: int, y: int, scale_x: float, scale_y: float, angle: float) -> None:
+        lib.mlx_put_transformed_image_to_window(self._ctx._ctx, self._win, image._img, int(x), int(y), float(scale_x), float(scale_y), float(angle))
+
+    def string_put(self, x: int, y: int, rgba: int, text: str) -> None:
+        ffi_text = ffi.new("char[]", text.encode('ascii', 'replace'))
+        lib.mlx_string_put(self._ctx._ctx, self._win, int(x), int(y), _rgbaToColor(rgba), ffi_text)
+
+    def on_event(self, event_type: EventType | int, fn: Callable[[int], None]) -> None:
+        lib.mlx_on_event(self._ctx._ctx, self._win, int(event_type), _makeEventCallback(fn), ffi.NULL)
+
+    def destroy(self) -> None:
+        if getattr(self, "_win", None):
+            lib.mlx_destroy_window(self._ctx._ctx, self._win)
+            self._win = ffi.NULL
+
+    def __del__(self):
+        try:
+            self.destroy()
+        except Exception:
+            pass
+
+class Image:
+    __slots__ = ("_ctx", "_img")
+
+    def __init__(self, ctx: Context, img) -> None:
+        self._ctx = ctx
+        self._img = img
+
+    def set_pixel(self, x: int, y: int, rgba: int) -> None:
+        lib.mlx_set_image_pixel(self._ctx._ctx, self._img, int(x), int(y), _rgbaToColor(rgba))
+
+    def get_pixel(self, x: int, y: int) -> int:
+        return lib.mlx_get_image_pixel(self._ctx._ctx, self._img, int(x), int(y))
+
+    def destroy(self) -> None:
+        if getattr(self, "_img", None):
+            lib.mlx_destroy_image(self._ctx._ctx, self._img)
+            self._img = ffi.NULL
+
+    def __del__(self):
+        try:
+            self.destroy()
+        except Exception:
+            pass

runtime/Includes/Core/UUID.h

@@ -7,9 +7,7 @@ namespace mlx
 	{
 		public:
 			UUID();
-			UUID(std::uint64_t uuid);
+			inline operator std::uint64_t() const noexcept { return m_uuid; }
-
-			inline operator std::uint64_t() const { return m_uuid; }
 
 		private:
 			std::uint64_t m_uuid;

runtime/Sources/Core/SDLManager.cpp

@@ -22,7 +22,7 @@ namespace mlx
 		MLX_PROFILE_FUNCTION();
 		s_instance = this;
 
-		m_drop_sdl_responsability = SDL_WasInit(SDL_INIT_VIDEO);
+		m_drop_sdl_responsability = SDL_WasInit(SDL_INIT_VIDEO) || std::getenv("MLX_HEADLESS_MODE") != nullptr;
 		if(m_drop_sdl_responsability) // is case the mlx is running in a sandbox like MacroUnitTester where SDL is already init
 			return;
 		SDL_SetMemoryFunctions(MemManager::Get().Malloc, MemManager::Get().Calloc, MemManager::Get().Realloc, MemManager::Get().Free);

runtime/Sources/Core/UUID.cpp

@@ -7,7 +7,14 @@ namespace mlx
 	static std::random_device random_device;
 	static std::mt19937_64 engine(random_device());
 	static std::uniform_int_distribution<std::uint64_t> uniform_distribution;
+	static std::unordered_set<std::uint64_t> registry;
 
-	UUID::UUID() : m_uuid(uniform_distribution(engine)) {}
+	UUID::UUID()
-	UUID::UUID(std::uint64_t uuid) : m_uuid(uuid) {}
+	{
+		do
+		{
+			m_uuid = uniform_distribution(engine);
+		} while(registry.contains(m_uuid));
+		registry.emplace(m_uuid);
+	}
 }

runtime/Sources/Renderer/Buffer.cpp

@@ -81,7 +81,7 @@ namespace mlx
 
 		VkCommandBuffer cmd = kvfCreateCommandBuffer(RenderCore::Get().GetDevice());
 		kvfBeginCommandBuffer(cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
-		kvfCopyBufferToBuffer(cmd, m_buffer, buffer.Get(), m_size);
+		kvfCopyBufferToBuffer(cmd, m_buffer, buffer.Get(), m_size, 0, 0);
 		kvfEndCommandBuffer(cmd);
 		VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice());
 		kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence);

runtime/Sources/Renderer/Image.cpp

@@ -218,7 +218,7 @@ namespace mlx
 	void Texture::SetPixel(int x, int y, mlx_color color) noexcept
 	{
 		MLX_PROFILE_FUNCTION();
-		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) > m_width || static_cast<std::uint32_t>(y) > m_height)
+		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) >= m_width || static_cast<std::uint32_t>(y) >= m_height)
 			return;
 		if(!m_staging_buffer.has_value())
 			OpenCPUBuffer();
@@ -232,7 +232,7 @@ namespace mlx
 	void Texture::SetRegion(int x, int y, int w, int h, mlx_color* pixels) noexcept
 	{
 		MLX_PROFILE_FUNCTION();
-		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) > m_width || static_cast<std::uint32_t>(y) > m_height)
+		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) >= m_width || static_cast<std::uint32_t>(y) >= m_height)
 			return;
 		if(w < 0 || h < 0)
 			return;
@@ -258,7 +258,7 @@ namespace mlx
 	void Texture::SetLinearRegion(int x, int y, std::size_t len, mlx_color* pixels) noexcept
 	{
 		MLX_PROFILE_FUNCTION();
-		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) > m_width || static_cast<std::uint32_t>(y) > m_height)
+		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) >= m_width || static_cast<std::uint32_t>(y) >= m_height)
 			return;
 		if(!m_staging_buffer.has_value())
 			OpenCPUBuffer();
@@ -282,7 +282,7 @@ namespace mlx
 	mlx_color Texture::GetPixel(int x, int y) noexcept
 	{
 		MLX_PROFILE_FUNCTION();
-		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) > m_width || static_cast<std::uint32_t>(y) > m_height)
+		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) >= m_width || static_cast<std::uint32_t>(y) >= m_height)
 			return { .rgba = 0x00000000 };
 		if(!m_staging_buffer.has_value())
 			OpenCPUBuffer();
@@ -295,7 +295,7 @@ namespace mlx
 	void Texture::GetRegion(int x, int y, int w, int h, mlx_color* dst) noexcept
 	{
 		MLX_PROFILE_FUNCTION();
-		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) > m_width || static_cast<std::uint32_t>(y) > m_height)
+		if(x < 0 || y < 0 || static_cast<std::uint32_t>(x) >= m_width || static_cast<std::uint32_t>(y) >= m_height)
 			return;
 		if(!m_staging_buffer.has_value())
 			OpenCPUBuffer();

runtime/Sources/Renderer/RenderCore.cpp

@@ -87,15 +87,24 @@ namespace mlx
 		kvfSetValidationErrorCallback(&ValidationErrorCallback);
 		kvfSetValidationWarningCallback(&WarningCallback);
 
+		std::vector<const char*> instance_extensions;
+		VkSurfaceKHR surface = VK_NULL_HANDLE;
+		std::unique_ptr<Window> window;
+
+		bool is_headless = std::getenv("MLX_HEADLESS_MODE") != nullptr;
+
+		if(!is_headless)
+		{
 			mlx_window_create_info info{};
 			info.title = "";
 			info.width = 1;
 			info.height = 1;
-		Window window(&info, true);
+			window = std::make_unique<Window>(&info, true);
-		std::vector<const char*> instance_extensions = window.GetRequiredVulkanInstanceExtentions();
+			instance_extensions = window->GetRequiredVulkanInstanceExtentions();
 			#ifdef MLX_PLAT_MACOS
 				instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
 			#endif
+		}
 
 		m_instance = kvfCreateInstance(instance_extensions.data(), instance_extensions.size());
 		DebugLog("Vulkan: instance created");
@@ -103,24 +112,33 @@ namespace mlx
 		loader->LoadInstance(m_instance);
 		LoadKVFInstanceVulkanFunctionPointers();
 
-		VkSurfaceKHR surface = window.CreateVulkanSurface(m_instance);
+		if(!is_headless)
-
+		{
+			surface = window->CreateVulkanSurface(m_instance);
 			m_physical_device = kvfPickGoodDefaultPhysicalDevice(m_instance, surface);
+		}
+		else
+			m_physical_device = kvfPickGoodPhysicalDevice(m_instance, VK_NULL_HANDLE, nullptr, 0);
+
+		Verify(m_physical_device != VK_NULL_HANDLE, "Could not find a suitable physical device");
 
 		// just for style
 		VkPhysicalDeviceProperties props;
 		vkGetPhysicalDeviceProperties(m_physical_device, &props);
 		DebugLog("Vulkan: physical device picked '%'", props.deviceName);
 
-		const char* device_extensions[] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
+		std::vector<const char*> device_extensions;
+		if(!is_headless)
+			device_extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
 		VkPhysicalDeviceFeatures features{};
 		vkGetPhysicalDeviceFeatures(m_physical_device, &features);
-		m_device = kvfCreateDevice(m_physical_device, device_extensions, sizeof(device_extensions) / sizeof(device_extensions[0]), &features);
+		m_device = kvfCreateDevice(m_physical_device, device_extensions.data(), device_extensions.size(), &features);
 		DebugLog("Vulkan: logical device created");
 
 		loader->LoadDevice(m_device);
 		LoadKVFDeviceVulkanFunctionPointers();
 
+		if(surface != VK_NULL_HANDLE)
 			vkDestroySurfaceKHR(m_instance, surface, nullptr);
 
 		VkAllocationCallbacks callbacks;

runtime/Sources/Renderer/Vulkan/VulkanLoader.cpp

@@ -28,6 +28,10 @@ namespace mlx
 	{
 		static inline PFN_vkVoidFunction vkGetInstanceProcAddrStub(Handle context, const char* name)
 		{
+			bool is_headless = std::getenv("MLX_HEADLESS_MODE") != nullptr;
+			if(is_headless && std::string_view(name).find("KHR") != std::string_view::npos)
+				return nullptr;
+
 			PFN_vkVoidFunction function = RenderCore::Get().vkGetInstanceProcAddr(static_cast<VkInstance>(context), name);
 			if(!function)
 				FatalError("Vulkan Loader: could not load '%'", name);
@@ -37,6 +41,10 @@ namespace mlx
 
 		static inline PFN_vkVoidFunction vkGetDeviceProcAddrStub(Handle context, const char* name)
 		{
+			bool is_headless = std::getenv("MLX_HEADLESS_MODE") != nullptr;
+			if(is_headless && std::string_view(name).find("KHR") != std::string_view::npos)
+				return nullptr;
+
 			PFN_vkVoidFunction function = RenderCore::Get().vkGetDeviceProcAddr(static_cast<VkDevice>(context), name);
 			if(!function)
 				FatalError("Vulkan Loader: could not load '%'", name);

third_party/kvf.h

@@ -51,7 +51,7 @@
 #ifndef KBZ_8_VULKAN_FRAMEWORK_H
 #define KBZ_8_VULKAN_FRAMEWORK_H
 
-#ifdef KVF_IMPL_VK_NO_PROTOTYPES
+#if defined(KVF_IMPL_VK_NO_PROTOTYPES) && !defined(VK_NO_PROTOTYPES)
 	#define VK_NO_PROTOTYPES
 #endif
 
@@ -159,7 +159,7 @@ VkSampler kvfCreateSampler(VkDevice device, VkFilter filters, VkSamplerAddressMo
 void kvfDestroySampler(VkDevice device, VkSampler sampler);
 
 VkBuffer kvfCreateBuffer(VkDevice device, VkBufferUsageFlags usage, VkDeviceSize size);
-void kvfCopyBufferToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkBuffer src, size_t size);
+void kvfCopyBufferToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkBuffer src, size_t size, size_t src_offset, size_t dst_offset);
 void kvfCopyBufferToImage(VkCommandBuffer cmd, VkImage dst, VkBuffer src, size_t buffer_offset, VkImageAspectFlagBits aspect, VkExtent3D extent);
 void kvfDestroyBuffer(VkDevice device, VkBuffer buffer);
 
@@ -374,12 +374,12 @@ void kvfCheckVk(VkResult result);
 #ifdef KVF_DESCRIPTOR_POOL_CAPACITY
 	#undef KVF_DESCRIPTOR_POOL_CAPACITY
 #endif
-#define KVF_DESCRIPTOR_POOL_CAPACITY 512
+#define KVF_DESCRIPTOR_POOL_CAPACITY 1024
 
 #ifdef KVF_COMMAND_POOL_CAPACITY
 	#undef KVF_COMMAND_POOL_CAPACITY
 #endif
-#define KVF_COMMAND_POOL_CAPACITY 512
+#define KVF_COMMAND_POOL_CAPACITY 1024
 
 typedef struct
 {
@@ -560,6 +560,7 @@ void __kvfCompleteDevice(VkPhysicalDevice physical, VkDevice device)
 
 	kvf_device->device = device;
 	kvf_device->cmd_pool = pool;
+	kvf_device->callbacks = NULL;
 	kvf_device->sets_pools = NULL;
 	kvf_device->sets_pools_size = 0;
 	kvf_device->cmd_buffers_size = 0;
@@ -1474,9 +1475,6 @@ int32_t __kvfScorePhysicalDevice(VkPhysicalDevice device, VkSurfaceKHR surface,
 	if(device_props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
 		score += 1000;
 
-	if(!device_features.geometryShader)
-		return -1;
-
 	score += device_props.limits.maxImageDimension2D;
 	score += device_props.limits.maxBoundDescriptorSets;
 
@@ -2277,7 +2275,7 @@ VkBuffer kvfCreateBuffer(VkDevice device, VkBufferUsageFlags usage, VkDeviceSize
 	return buffer;
 }
 
-void kvfCopyBufferToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkBuffer src, size_t size)
+void kvfCopyBufferToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkBuffer src, size_t size, size_t src_offset, size_t dst_offset)
 {
 	KVF_ASSERT(cmd != VK_NULL_HANDLE);
 	KVF_ASSERT(dst != VK_NULL_HANDLE);
@@ -2288,6 +2286,8 @@ void kvfCopyBufferToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkBuffer src, size
 	#endif
 	VkBufferCopy copy_region = {};
 	copy_region.size = size;
+	copy_region.srcOffset = src_offset;
+	copy_region.dstOffset = dst_offset;
 	KVF_GET_DEVICE_FUNCTION(vkCmdCopyBuffer)(cmd, src, dst, 1, &copy_region);
 }
 
@@ -2543,7 +2543,7 @@ VkAttachmentDescription kvfBuildAttachmentDescription(KvfImageType type, VkForma
 		__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
 		KVF_ASSERT(kvf_swapchain != NULL);
 		KVF_ASSERT(kvf_swapchain->images_count != 0);
-		return kvfBuildAttachmentDescription(KVF_IMAGE_COLOR, kvf_swapchain->images_format, VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, clear, VK_SAMPLE_COUNT_1_BIT);
+		return kvfBuildAttachmentDescription(KVF_IMAGE_COLOR, kvf_swapchain->images_format, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, clear, VK_SAMPLE_COUNT_1_BIT);
 	}
 #endif
 

third_party/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      8
+#define STD_VIDEO_VP9_REFS_PER_FRAME      3
+#define STD_VIDEO_VP9_MAX_REF_FRAMES      4
+#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2
+#define STD_VIDEO_VP9_MAX_SEGMENTS        8
+#define STD_VIDEO_VP9_SEG_LVL_MAX         4
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3
+
+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

third_party/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

third_party/vulkan/vulkan.h

@@ -96,4 +96,8 @@
 #include "vulkan_beta.h"
 #endif
 
+#ifdef VK_USE_PLATFORM_OHOS
+#include "vulkan_ohos.h"
+#endif
+
 #endif // VULKAN_H_

third_party/vulkan/vulkan_android.h

@@ -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,20 @@ 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.

third_party/vulkan/vulkan_beta.h

@@ -129,6 +129,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer
 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,
@@ -136,42 +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,
     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.

third_party/vulkan/vulkan_directfb.h

@@ -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
 }

third_party/vulkan/vulkan_fuchsia.h

@@ -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
 }

third_party/vulkan/vulkan_ggp.h

@@ -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.

third_party/vulkan/vulkan_hpp_macros.hpp

@@ -5,6 +5,7 @@
 
 // This header is generated from the Khronos Vulkan XML API Registry.
 
+
 #ifndef VULKAN_HPP_MACROS_HPP
 #define VULKAN_HPP_MACROS_HPP
 
@@ -79,11 +80,11 @@
 #  define __has_include( x ) false
 #endif
 
-#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
+#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 ( 201803 <= __cpp_lib_span )
+#if defined( __cpp_lib_span ) && ( 201803 <= __cpp_lib_span )
 #  define VULKAN_HPP_SUPPORT_SPAN
 #endif
 
@@ -92,12 +93,11 @@
 #endif
 
 #ifndef VK_USE_64_BIT_PTR_DEFINES
-#  if defined( __LP64__ ) || defined( _WIN64 ) || ( defined( __x86_64__ ) && !defined( __ILP32__ ) ) || defined( _M_X64 ) || defined( __ia64 ) || \
+    #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)
-    defined( _M_IA64 ) || defined( __aarch64__ ) || defined( __powerpc64__ ) || ( defined( __riscv ) && __riscv_xlen == 64 )
+        #define VK_USE_64_BIT_PTR_DEFINES 1
-#    define VK_USE_64_BIT_PTR_DEFINES 1
+    #else
-#  else
+        #define VK_USE_64_BIT_PTR_DEFINES 0
-#    define VK_USE_64_BIT_PTR_DEFINES 0
+    #endif
-#  endif
 #endif
 
 // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
@@ -323,4 +323,5 @@ namespace VULKAN_HPP_NAMESPACE
 #  define VULKAN_HPP_RAII_CREATE_NOEXCEPT
 #endif
 
+
 #endif

third_party/vulkan/vulkan_ios.h

@@ -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
 }

third_party/vulkan/vulkan_macos.h

@@ -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
 }

third_party/vulkan/vulkan_metal.h

@@ -40,12 +40,14 @@ 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.
@@ -183,10 +185,12 @@ 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.
@@ -217,17 +221,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, con
 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
 }

third_party/vulkan/vulkan_ohos.h

@@ -0,0 +1,53 @@
+#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_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 VkOHSurfaceCreateInfoOHOS {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkSurfaceCreateFlagsOHOS    flags;
+    OHNativeWindow*             window;
+} VkOHSurfaceCreateInfoOHOS;
+
+typedef VkOHSurfaceCreateInfoOHOS 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
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

third_party/vulkan/vulkan_screen.h

@@ -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
 }

third_party/vulkan/vulkan_vi.h

@@ -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
 }

third_party/vulkan/vulkan_video.cppm

@@ -0,0 +1,171 @@
+// 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>
+
+#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
+#  define VULKAN_HPP_ENABLE_STD_MODULE
+#endif
+
+#include <vulkan/vulkan_video.hpp>
+
+export module vulkan_video_hpp;
+
+export namespace VULKAN_HPP_NAMESPACE
+{
+  namespace VULKAN_HPP_VIDEO_NAMESPACE
+  {
+
+    //=============
+    //=== ENUMs ===
+    //=============
+
+    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;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
+    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;
+    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;
+    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;
+
+    //===============
+    //=== STRUCTS ===
+    //===============
+
+    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;
+    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;
+    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;
+    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;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo;
+    using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+
+  }  // namespace VULKAN_HPP_VIDEO_NAMESPACE
+}  // namespace VULKAN_HPP_NAMESPACE

third_party/vulkan/vulkan_video.hpp

@@ -13,15 +13,15 @@
 
 #include <vk_video/vulkan_video_codec_av1std.h>
 #include <vk_video/vulkan_video_codec_av1std_decode.h>
-#if ( 301 < VK_HEADER_VERSION )
+#include <vk_video/vulkan_video_codec_av1std_encode.h>
-#  include <vk_video/vulkan_video_codec_av1std_encode.h>
-#endif
 #include <vk_video/vulkan_video_codec_h264std.h>
 #include <vk_video/vulkan_video_codec_h264std_decode.h>
 #include <vk_video/vulkan_video_codec_h264std_encode.h>
 #include <vk_video/vulkan_video_codec_h265std.h>
 #include <vk_video/vulkan_video_codec_h265std_decode.h>
 #include <vk_video/vulkan_video_codec_h265std_encode.h>
+#include <vk_video/vulkan_video_codec_vp9std.h>
+#include <vk_video/vulkan_video_codec_vp9std_decode.h>
 #include <vk_video/vulkan_video_codecs_common.h>
 
 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE )
@@ -37,6 +37,7 @@ namespace VULKAN_HPP_NAMESPACE
     //=== ENUMs ===
     //=============
 
+#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
     //=== vulkan_video_codec_h264std ===
 
     enum class H264ChromaFormatIdc
@@ -185,7 +186,9 @@ namespace VULKAN_HPP_NAMESPACE
       ePrecoded      = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED,
       eInvalid       = STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
     //=== vulkan_video_codec_h264std_decode ===
 
     enum class DecodeH264FieldOrderCount
@@ -194,7 +197,9 @@ namespace VULKAN_HPP_NAMESPACE
       eBottom  = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM,
       eInvalid = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
     //=== vulkan_video_codec_h265std ===
 
     enum class H265ChromaFormatIdc
@@ -273,7 +278,80 @@ namespace VULKAN_HPP_NAMESPACE
       eExtendedSar = STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR,
       eInvalid     = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
+    //=== vulkan_video_codec_vp9std ===
+
+    enum class VP9Profile
+    {
+      e0       = STD_VIDEO_VP9_PROFILE_0,
+      e1       = STD_VIDEO_VP9_PROFILE_1,
+      e2       = STD_VIDEO_VP9_PROFILE_2,
+      e3       = STD_VIDEO_VP9_PROFILE_3,
+      eInvalid = STD_VIDEO_VP9_PROFILE_INVALID
+    };
+
+    enum class VP9Level
+    {
+      e1_0     = STD_VIDEO_VP9_LEVEL_1_0,
+      e1_1     = STD_VIDEO_VP9_LEVEL_1_1,
+      e2_0     = STD_VIDEO_VP9_LEVEL_2_0,
+      e2_1     = STD_VIDEO_VP9_LEVEL_2_1,
+      e3_0     = STD_VIDEO_VP9_LEVEL_3_0,
+      e3_1     = STD_VIDEO_VP9_LEVEL_3_1,
+      e4_0     = STD_VIDEO_VP9_LEVEL_4_0,
+      e4_1     = STD_VIDEO_VP9_LEVEL_4_1,
+      e5_0     = STD_VIDEO_VP9_LEVEL_5_0,
+      e5_1     = STD_VIDEO_VP9_LEVEL_5_1,
+      e5_2     = STD_VIDEO_VP9_LEVEL_5_2,
+      e6_0     = STD_VIDEO_VP9_LEVEL_6_0,
+      e6_1     = STD_VIDEO_VP9_LEVEL_6_1,
+      e6_2     = STD_VIDEO_VP9_LEVEL_6_2,
+      eInvalid = STD_VIDEO_VP9_LEVEL_INVALID
+    };
+
+    enum class VP9FrameType
+    {
+      eKey     = STD_VIDEO_VP9_FRAME_TYPE_KEY,
+      eNonKey  = STD_VIDEO_VP9_FRAME_TYPE_NON_KEY,
+      eInvalid = STD_VIDEO_VP9_FRAME_TYPE_INVALID
+    };
+
+    enum class VP9ReferenceName
+    {
+      eIntraFrame  = STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME,
+      eLastFrame   = STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME,
+      eGoldenFrame = STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME,
+      eAltrefFrame = STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME,
+      eInvalid     = STD_VIDEO_VP9_REFERENCE_NAME_INVALID
+    };
+
+    enum class VP9InterpolationFilter
+    {
+      eEighttap       = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP,
+      eEighttapSmooth = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH,
+      eEighttapSharp  = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP,
+      eBilinear       = STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR,
+      eSwitchable     = STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE,
+      eInvalid        = STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID
+    };
+
+    enum class VP9ColorSpace
+    {
+      eUnknown  = STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN,
+      eBt601    = STD_VIDEO_VP9_COLOR_SPACE_BT_601,
+      eBt709    = STD_VIDEO_VP9_COLOR_SPACE_BT_709,
+      eSmpte170 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170,
+      eSmpte240 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240,
+      eBt2020   = STD_VIDEO_VP9_COLOR_SPACE_BT_2020,
+      eReserved = STD_VIDEO_VP9_COLOR_SPACE_RESERVED,
+      eRgb      = STD_VIDEO_VP9_COLOR_SPACE_RGB,
+      eInvalid  = STD_VIDEO_VP9_COLOR_SPACE_INVALID
+    };
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
     //=== vulkan_video_codec_av1std ===
 
     enum class AV1Profile
@@ -433,11 +511,13 @@ namespace VULKAN_HPP_NAMESPACE
       eReserved  = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED,
       eInvalid   = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID
     };
+#endif
 
     //===============
     //=== STRUCTS ===
     //===============
 
+#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
     //=== vulkan_video_codec_h264std ===
 
     struct H264SpsVuiFlags
@@ -891,7 +971,9 @@ namespace VULKAN_HPP_NAMESPACE
       int8_t                                                                     second_chroma_qp_index_offset = {};
       const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists                 = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
     //=== vulkan_video_codec_h264std_decode ===
 
     struct DecodeH264PictureInfoFlags
@@ -1068,7 +1150,9 @@ namespace VULKAN_HPP_NAMESPACE
       uint16_t                                                                                         reserved    = {};
       VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ )
     //=== vulkan_video_codec_h264std_encode ===
 
     struct EncodeH264WeightTableFlags
@@ -1619,7 +1703,9 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled;
       const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
     //=== vulkan_video_codec_h265std ===
 
     struct H265DecPicBufMgr
@@ -2736,7 +2822,9 @@ namespace VULKAN_HPP_NAMESPACE
       const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists *                          pScalingLists                             = {};
       const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries *               pPredictorPaletteEntries                  = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
     //=== vulkan_video_codec_h265std_decode ===
 
     struct DecodeH265PictureInfoFlags
@@ -2911,7 +2999,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags flags          = {};
       int32_t                                                                        PicOrderCntVal = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ )
     //=== vulkan_video_codec_h265std_encode ===
 
     struct EncodeH265WeightTableFlags
@@ -3444,7 +3534,385 @@ namespace VULKAN_HPP_NAMESPACE
       int32_t                                                           PicOrderCntVal = {};
       uint8_t                                                           TemporalId     = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
+    //=== vulkan_video_codec_vp9std ===
+
+    struct VP9ColorConfigFlags
+    {
+      using NativeType = StdVideoVP9ColorConfigFlags;
+
+      operator StdVideoVP9ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoVP9ColorConfigFlags *>( this );
+      }
+
+      operator StdVideoVP9ColorConfigFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoVP9ColorConfigFlags *>( this );
+      }
+
+      operator StdVideoVP9ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoVP9ColorConfigFlags *>( this );
+      }
+
+      operator StdVideoVP9ColorConfigFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoVP9ColorConfigFlags *>( this );
+      }
+
+      bool operator==( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( color_range == rhs.color_range ) && ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint32_t color_range : 1;
+      uint32_t reserved    : 31;
+    };
+
+    struct VP9ColorConfig
+    {
+      using NativeType = StdVideoVP9ColorConfig;
+
+      operator StdVideoVP9ColorConfig const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoVP9ColorConfig *>( this );
+      }
+
+      operator StdVideoVP9ColorConfig &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoVP9ColorConfig *>( this );
+      }
+
+      operator StdVideoVP9ColorConfig const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoVP9ColorConfig *>( this );
+      }
+
+      operator StdVideoVP9ColorConfig *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoVP9ColorConfig *>( this );
+      }
+
+      bool operator==( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) &&
+               ( reserved1 == rhs.reserved1 ) && ( color_space == rhs.color_space );
+      }
+
+      bool operator!=( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags flags         = {};
+      uint8_t                                                               BitDepth      = {};
+      uint8_t                                                               subsampling_x = {};
+      uint8_t                                                               subsampling_y = {};
+      uint8_t                                                               reserved1     = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace color_space = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace::eUnknown;
+    };
+
+    struct VP9LoopFilterFlags
+    {
+      using NativeType = StdVideoVP9LoopFilterFlags;
+
+      operator StdVideoVP9LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoVP9LoopFilterFlags *>( this );
+      }
+
+      operator StdVideoVP9LoopFilterFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoVP9LoopFilterFlags *>( this );
+      }
+
+      operator StdVideoVP9LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoVP9LoopFilterFlags *>( this );
+      }
+
+      operator StdVideoVP9LoopFilterFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoVP9LoopFilterFlags *>( this );
+      }
+
+      bool operator==( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) &&
+               ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint32_t loop_filter_delta_enabled : 1;
+      uint32_t loop_filter_delta_update  : 1;
+      uint32_t reserved                  : 30;
+    };
+
+    struct VP9LoopFilter
+    {
+      using NativeType = StdVideoVP9LoopFilter;
+
+      operator StdVideoVP9LoopFilter const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoVP9LoopFilter *>( this );
+      }
+
+      operator StdVideoVP9LoopFilter &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoVP9LoopFilter *>( this );
+      }
+
+      operator StdVideoVP9LoopFilter const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoVP9LoopFilter *>( this );
+      }
+
+      operator StdVideoVP9LoopFilter *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoVP9LoopFilter *>( this );
+      }
+
+      bool operator==( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) &&
+               ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) &&
+               ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas );
+      }
+
+      bool operator!=( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags                flags                   = {};
+      uint8_t                                                                             loop_filter_level       = {};
+      uint8_t                                                                             loop_filter_sharpness   = {};
+      uint8_t                                                                             update_ref_delta        = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_VP9_MAX_REF_FRAMES>          loop_filter_ref_deltas  = {};
+      uint8_t                                                                             update_mode_delta       = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {};
+    };
+
+    struct VP9SegmentationFlags
+    {
+      using NativeType = StdVideoVP9SegmentationFlags;
+
+      operator StdVideoVP9SegmentationFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoVP9SegmentationFlags *>( this );
+      }
+
+      operator StdVideoVP9SegmentationFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoVP9SegmentationFlags *>( this );
+      }
+
+      operator StdVideoVP9SegmentationFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoVP9SegmentationFlags *>( this );
+      }
+
+      operator StdVideoVP9SegmentationFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoVP9SegmentationFlags *>( this );
+      }
+
+      bool operator==( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( segmentation_update_map == rhs.segmentation_update_map ) && ( segmentation_temporal_update == rhs.segmentation_temporal_update ) &&
+               ( segmentation_update_data == rhs.segmentation_update_data ) && ( segmentation_abs_or_delta_update == rhs.segmentation_abs_or_delta_update ) &&
+               ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      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;
+    };
+
+    struct VP9Segmentation
+    {
+      using NativeType = StdVideoVP9Segmentation;
+
+      operator StdVideoVP9Segmentation const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoVP9Segmentation *>( this );
+      }
+
+      operator StdVideoVP9Segmentation &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoVP9Segmentation *>( this );
+      }
+
+      operator StdVideoVP9Segmentation const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoVP9Segmentation *>( this );
+      }
+
+      operator StdVideoVP9Segmentation *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoVP9Segmentation *>( this );
+      }
+
+      bool operator==( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( segmentation_tree_probs == rhs.segmentation_tree_probs ) &&
+               ( segmentation_pred_prob == rhs.segmentation_pred_prob ) && ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData );
+      }
+
+      bool operator!=( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags                               flags                   = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS>             segmentation_tree_probs = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB>              segmentation_pred_prob  = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTS>                            FeatureEnabled          = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int16_t, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX> FeatureData             = {};
+    };
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ )
+    //=== vulkan_video_codec_vp9std_decode ===
+
+    struct DecodeVP9PictureInfoFlags
+    {
+      using NativeType = StdVideoDecodeVP9PictureInfoFlags;
+
+      operator StdVideoDecodeVP9PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoDecodeVP9PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeVP9PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoDecodeVP9PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeVP9PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeVP9PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoDecodeVP9PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeVP9PictureInfoFlags *>( this );
+      }
+
+      bool operator==( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( error_resilient_mode == rhs.error_resilient_mode ) && ( intra_only == rhs.intra_only ) &&
+               ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && ( refresh_frame_context == rhs.refresh_frame_context ) &&
+               ( frame_parallel_decoding_mode == rhs.frame_parallel_decoding_mode ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
+               ( show_frame == rhs.show_frame ) && ( UsePrevFrameMvs == rhs.UsePrevFrameMvs ) && ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      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;
+    };
+
+    struct DecodeVP9PictureInfo
+    {
+      using NativeType = StdVideoDecodeVP9PictureInfo;
+
+      operator StdVideoDecodeVP9PictureInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoDecodeVP9PictureInfo *>( this );
+      }
+
+      operator StdVideoDecodeVP9PictureInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoDecodeVP9PictureInfo *>( this );
+      }
+
+      operator StdVideoDecodeVP9PictureInfo const *() const VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<const StdVideoDecodeVP9PictureInfo *>( this );
+      }
+
+      operator StdVideoDecodeVP9PictureInfo *() VULKAN_HPP_NOEXCEPT
+      {
+        return reinterpret_cast<StdVideoDecodeVP9PictureInfo *>( this );
+      }
+
+      bool operator==( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( profile == rhs.profile ) && ( frame_type == rhs.frame_type ) && ( frame_context_idx == rhs.frame_context_idx ) &&
+               ( reset_frame_context == rhs.reset_frame_context ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) &&
+               ( ref_frame_sign_bias_mask == rhs.ref_frame_sign_bias_mask ) && ( interpolation_filter == rhs.interpolation_filter ) &&
+               ( base_q_idx == rhs.base_q_idx ) && ( delta_q_y_dc == rhs.delta_q_y_dc ) && ( delta_q_uv_dc == rhs.delta_q_uv_dc ) &&
+               ( delta_q_uv_ac == rhs.delta_q_uv_ac ) && ( tile_cols_log2 == rhs.tile_cols_log2 ) && ( tile_rows_log2 == rhs.tile_rows_log2 ) &&
+               ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pLoopFilter == rhs.pLoopFilter ) &&
+               ( pSegmentation == rhs.pSegmentation );
+      }
+
+      bool operator!=( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags flags   = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile                profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile::e0;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType frame_type          = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType::eKey;
+      uint8_t                                                        frame_context_idx   = {};
+      uint8_t                                                        reset_frame_context = {};
+      uint8_t                                                        refresh_frame_flags = {};
+      uint8_t                                                        ref_frame_sign_bias_mask = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter interpolation_filter =
+        VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter::eEighttap;
+      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 = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, 3>                         reserved1      = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig *  pColorConfig   = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter *   pLoopFilter    = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation * pSegmentation  = {};
+    };
+#endif
+
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
     //=== vulkan_video_codec_av1std ===
 
     struct AV1ColorConfigFlags
@@ -4284,7 +4752,9 @@ namespace VULKAN_HPP_NAMESPACE
       const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig           = {};
       const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo *  pTimingInfo            = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ )
     //=== vulkan_video_codec_av1std_decode ===
 
     struct DecodeAV1PictureInfoFlags
@@ -4518,7 +4988,9 @@ namespace VULKAN_HPP_NAMESPACE
       uint8_t                                                                       OrderHint        = {};
       VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES>   SavedOrderHints  = {};
     };
+#endif
 
+#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ )
     //=== vulkan_video_codec_av1std_encode ===
 
     struct EncodeAV1DecoderModelInfo
@@ -4931,6 +5403,7 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3>               reserved1  = {};
       const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
     };
+#endif
 
   }  // namespace VULKAN_HPP_VIDEO_NAMESPACE
 }  // namespace VULKAN_HPP_NAMESPACE

third_party/vulkan/vulkan_wayland.h

@@ -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
 }

third_party/vulkan/vulkan_win32.h

@@ -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
 }

third_party/vulkan/vulkan_xcb.h

@@ -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
 }

third_party/vulkan/vulkan_xlib.h

@@ -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
 }

third_party/vulkan/vulkan_xlib_xrandr.h

@@ -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
 }

valgrind.supp

@@ -158,3 +158,66 @@
    obj:*libdbus-1.so*
    ...
 }
+{
+   vulkan_lvp_leaks
+   Memcheck:Leak
+   fun:*
+   ...
+   obj:*libvulkan_lvp.so*
+   ...
+}
+{
+   vulkan_intel_leaks
+   Memcheck:Leak
+   fun:*
+   ...
+   obj:*libvulkan_intel.so*
+   ...
+}
+{
+   vulkan_base_leaks
+   Memcheck:Leak
+   fun:*
+   ...
+   obj:*libvulkan.so*
+   ...
+}
+{
+   vulkan_mesa_leaks
+   Memcheck:Leak
+   fun:*
+   ...
+   obj:*libVkLayer_MESA_device_select.so*
+   ...
+}
+{
+   vulkan_read_errors
+   Memcheck:Addr1
+   ...
+   obj:*libvulkan*
+   ...
+}
+{
+   vulkan_read_errors_intel
+   Memcheck:Addr1
+   ...
+   obj:*libvulkan_intel.so*
+   ...
+}
+{
+   nvidia_thread_read_errors
+   Memcheck:Addr1
+   ...
+   obj:*libnvidia-glcore.so*
+   ...
+   fun:start_thread
+   ...
+}
+{
+   nvidia_specific_thread_error
+   Memcheck:Addr1
+   obj:*libnvidia-glcore.so.550.120*
+   obj:*libnvidia-glcore.so.550.120*
+   fun:start_thread
+   fun:clone
+}

xmake.lua

@@ -1,6 +1,6 @@
 -- Global settings
 
-add_requires("libsdl", { configs = { sdlmain = false } })
+add_requires("libsdl2", { configs = { sdlmain = false } })
 
 add_rules("mode.debug", "mode.release", "mode.releasedbg")
 set_languages("cxx20", "c11")
@@ -63,7 +63,7 @@ target("mlx")
 
 	add_files("runtime/Sources/**.cpp")
 
-	add_packages("libsdl")
+	add_packages("libsdl2")
 
 	if is_mode("debug") then
 		add_defines("DEBUG")
@@ -98,5 +98,5 @@ target("Test")
 
 	add_defines("SDL_MAIN_HANDLED")
 
-	add_packages("libsdl")
+	add_packages("libsdl2")
 target_end()