[BOT] update dependencies

Using integer positions (x and y), the displayed image could suffer from
rounding errors with rotation. Leading to jittering on most dynamically
resized images trying to fit the window while rotating (common
optimization done in projects like Cub3D). This PR aims to fix this
issue by using float parameters for positioning in the function

.github/workflows/fetch_dependencies.yml

@@ -11,7 +11,7 @@ jobs:
 
     steps:
     - name: Checkout Repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     - name: Run Fetch Dependencies Script
       run: cd scripts && bash ./fetch_dependencies.sh

.github/workflows/linux_clang.yml

@@ -23,7 +23,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     - name: Install system dependencies
       run: |

.github/workflows/linux_gcc.yml

@@ -23,7 +23,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     - name: Install system dependencies
       run: |

.github/workflows/linux_meson.yml

@@ -22,7 +22,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Install system dependencies
         run: |
@@ -30,7 +30,7 @@ jobs:
           sudo apt-get -y install mesa-common-dev clang libsdl2-2.0-0 libsdl2-dev build-essential libvulkan-dev 
 
       - name: Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v7
         with:
           python-version: '3.11'
 

.github/workflows/macos.yml

@@ -23,7 +23,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     # Install system dependencies
     - name: Install Dependancies

.github/workflows/macos_meson.yml

@@ -22,14 +22,14 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Install system dependencies
         run: |
             brew install SDL2
 
       - name: Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v7
         with:
           python-version: '3.11'
 

.github/workflows/tests.yml

@@ -23,7 +23,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     - uses: NcStudios/VulkanCI@v1.2
 
@@ -69,7 +69,7 @@ jobs:
     # Save dependencies
     - name: Save cached xmake dependencies
       if: ${{ !steps.restore-depcache.outputs.cache-hit }}
-      uses: actions/cache/save@v5
+      uses: actions/cache/save@v6
       with:
         path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
         key: ${{ steps.restore-depcache.outputs.cache-primary-key }}

.github/workflows/windows.yml

@@ -28,7 +28,7 @@ jobs:
       run: echo "key=$(date +'%W')" >> $GITHUB_OUTPUT
 
     - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v7
 
     # Force xmake to a specific folder (for cache)
     - name: Set xmake env

.github/workflows/windows_meson.yml

@@ -19,14 +19,14 @@ jobs:
       matrix:
         platform: ['x64', 'x86']
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0
 
       # Install a 32-bit Python so building related stuff work.
       - name: Setup x86 Python
         if: matrix.platform == 'x86'
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v7
         with:
           architecture: 'x86'
           python-version: '3.12'
@@ -52,7 +52,7 @@ jobs:
       CC: clang-cl
       CXX: clang-cl
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0
 
@@ -75,7 +75,7 @@ jobs:
       matrix:
         platform: ['UCRT64', 'CLANG64']
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v7
         with:
           fetch-depth: 0
 

example/main.c

@@ -44,11 +44,16 @@ void update(void* param)
 	mlx_set_font(mlx->mlx, "default");
 	mlx_string_put(mlx->mlx, mlx->win, 20, 50, (mlx_color){ .rgba = 0xFFFFFFFF }, "that's a text");
 
+	int win_width;
+	int win_height;
+
+	mlx_get_window_size(mlx->mlx, mlx->win, &win_width, &win_height);
+
 	uint32_t color = 0;
-	for(int j = 0; j < 400; j++)
+	for(int j = 0; j < win_height; j++)
 	{
 		mlx_pixel_put(mlx->mlx, mlx->win, j, j, (mlx_color){ .rgba = 0x0000FFFF + (color << 24) });
-		mlx_pixel_put(mlx->mlx, mlx->win, 399 - j, j, (mlx_color){ .rgba = 0x0000FFFF });
+		mlx_pixel_put(mlx->mlx, mlx->win, win_width - j, j, (mlx_color){ .rgba = 0x0000FFFF });
 		color += (color < 255);
 	}
 
@@ -172,6 +177,8 @@ int main(void)
 	mlx.logo_png = mlx_new_image_from_file(mlx.mlx, "42_logo.png", &dummy, &dummy);
 	mlx.logo_jpg = mlx_new_image_from_file(mlx.mlx, "42_logo.jpg", &dummy, &dummy);
 
+	mlx_set_window_icon(mlx.mlx, mlx.win, mlx.logo_png);
+
 	mlx_pixel_put(mlx.mlx, mlx.win, 200, 10, (mlx_color){ .rgba = 0xFF00FFFF });
 	mlx_put_image_to_window(mlx.mlx, mlx.win, mlx.logo_png, 0, 0);
 

includes/mlx.h

@@ -148,7 +148,7 @@ MLX_API void mlx_set_window_position(mlx_context mlx, mlx_window win, int x, int
  * @brief            Sets window size
  *
  * @param mlx        Internal MLX application
- * @param win        Internal window to move
+ * @param win        Internal window to resize
  * @param width      New width
  * @param height     New height
  */
@@ -158,16 +158,25 @@ MLX_API void mlx_set_window_size(mlx_context mlx, mlx_window win, int width, int
  * @brief            Sets window title
  *
  * @param mlx        Internal MLX application
- * @param win        Internal window to move
+ * @param win        Internal window to modify
  * @param title      New title
  */
 MLX_API void mlx_set_window_title(mlx_context mlx, mlx_window win, const char* title);
 
+/**
+ * @brief            Sets window icon
+ *
+ * @param mlx        Internal MLX application
+ * @param win        Internal window to modify
+ * @param image      New icon image
+ */
+MLX_API void mlx_set_window_icon(mlx_context mlx, mlx_window win, mlx_image image);
+
 /**
  * @brief            Enables/Disables window fullscreen mode
  *
  * @param mlx        Internal MLX application
- * @param win        Internal window to move
+ * @param win        Internal window to modify
  * @param enable     Switch or not to fullscreen
  */
 MLX_API void mlx_set_window_fullscreen(mlx_context mlx, mlx_window win, bool enable);
@@ -176,7 +185,7 @@ MLX_API void mlx_set_window_fullscreen(mlx_context mlx, mlx_window win, bool ena
  * @brief            Gets window position
  *
  * @param mlx        Internal MLX application
- * @param win        Internal window to move
+ * @param win        Internal window to get from
  * @param x          Pointers to get position of the window
  * @param y          Pointers to get position of the window
  */
@@ -186,7 +195,7 @@ MLX_API void mlx_get_window_position(mlx_context mlx, mlx_window win, int* x, in
  * @brief            Gets window size
  *
  * @param mlx        Internal MLX application
- * @param win        Internal window to move
+ * @param win        Internal window to get from
  * @param x          Pointers to get size of the window
  * @param y          Pointers to get size of the window
  */
@@ -313,7 +322,10 @@ MLX_API void mlx_on_event(mlx_context mlx, mlx_window win, mlx_event_type event,
  * @param x          X coordinate
  * @param y          Y coordinate
  * @param color      Color of the pixel
+ *
+ * WARNING: This function isn't performant, consider drawing to an image beforehand.
  */
+MLX_DEPRECATED("Use an image rather than directly communicating with the window")
 MLX_API void mlx_pixel_put(mlx_context mlx, mlx_window win, int x, int y, mlx_color color);
 
 

includes/mlx_extended.h

@@ -75,7 +75,6 @@ MLX_API void mlx_restore_window(mlx_context mlx, mlx_window win);
 
         /* Pixels drawing related functions */
 
-
 /**
  * @brief            Put an array of pixels in the window
  *
@@ -85,7 +84,12 @@ MLX_API void mlx_restore_window(mlx_context mlx, mlx_window win);
  * @param y          Y coordinate
  * @param pixels     Array of pixels
  * @param pixels_number Number of pixels
+ *
+ * Note: it is responsability of the user to make sure the size of `pixels` is
+ * big enough for the given array.
+ * WARNING: This function isn't performant, consider drawing to an image beforehand.
  */
+MLX_DEPRECATED("Use an image rather than directly communicating with the window")
 MLX_API void mlx_pixel_put_array(mlx_context mlx, mlx_window win, int x, int y, mlx_color* pixels, size_t pixels_number);
 
 /**
@@ -101,13 +105,27 @@ MLX_API void mlx_pixel_put_array(mlx_context mlx, mlx_window win, int x, int y,
  *
  * Note: it is responsability of the user to make sure the size of `pixels` is
  * big enough for the given region.
+ * WARNING: This function isn't performant, consider drawing to an image beforehand.
  */
+MLX_DEPRECATED("Use an image rather than directly communicating with the window")
 MLX_API void mlx_pixel_put_region(mlx_context mlx, mlx_window win, int x, int y, int w, int h, mlx_color* pixels);
 
 
 
         /* Images related functions */
 
+/**
+* @brief            Set image rectangle
+*
+* @param mlx        Internal MLX application
+* @param img        Internal image
+* @param x          X coordinate in the image
+* @param y          Y coordinate in the image
+* @param w          Width of the rectangle
+* @param y          Height of the rectangle
+* @param color      Color of the rectangle
+*/
+MLX_API void mlx_set_image_rectangle(mlx_context mlx, mlx_image image, int x, int y, int w, int h, mlx_color color);
 
 /**
  * @brief            Get image region
@@ -153,7 +171,7 @@ MLX_API void mlx_set_image_region(mlx_context mlx, mlx_image image, int x, int y
  * @param scale_y    Scale y of the image
  * @param angle      Rotation angle of the image (clockwise)
  */
-MLX_API 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);
+MLX_API void mlx_put_transformed_image_to_window(mlx_context mlx, mlx_window win, mlx_image image, float x, float y, float scale_x, float scale_y, float angle);
 
 /**
  * @brief            Get direct pointers to hidden functions

includes/mlx_keycodes.h

@@ -0,0 +1,168 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   mlx_keycodes.h                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: rprieur <marvin@42.fr>                     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/08/09 00:15:49 by rprieur           #+#    #+#             */
+/*   Updated: 2026/08/09 00:16:30 by rprieur          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+// MacroLibX official repo https://github.com/seekrs/MacroLibX
+// MacroLibX official website https://macrolibx.kbz8.me/
+
+#ifndef MACROLIB_X_KEYCODES_H
+#define MACROLIB_X_KEYCODES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief           Event codes for physical keyboard keys
+ */
+typedef enum mlx_key_event_code
+{
+	MLX_KEY_A				= 4,
+	MLX_KEY_B				= 5,
+	MLX_KEY_C				= 6,
+	MLX_KEY_D				= 7,
+	MLX_KEY_E				= 8,
+	MLX_KEY_F				= 9,
+	MLX_KEY_G				= 10,
+	MLX_KEY_H				= 11,
+	MLX_KEY_I				= 12,
+	MLX_KEY_J				= 13,
+	MLX_KEY_K				= 14,
+	MLX_KEY_L				= 15,
+	MLX_KEY_M				= 16,
+	MLX_KEY_N				= 17,
+	MLX_KEY_O				= 18,
+	MLX_KEY_P				= 19,
+	MLX_KEY_Q				= 20,
+	MLX_KEY_R				= 21,
+	MLX_KEY_S				= 22,
+	MLX_KEY_T				= 23,
+	MLX_KEY_U				= 24,
+	MLX_KEY_V				= 25,
+	MLX_KEY_W				= 26,
+	MLX_KEY_X				= 27,
+	MLX_KEY_Y				= 28,
+	MLX_KEY_Z				= 29,
+	MLX_KEY_1				= 30,
+	MLX_KEY_2				= 31,
+	MLX_KEY_3				= 32,
+	MLX_KEY_4				= 33,
+	MLX_KEY_5				= 34,
+	MLX_KEY_6				= 35,
+	MLX_KEY_7				= 36,
+	MLX_KEY_8				= 37,
+	MLX_KEY_9				= 38,
+	MLX_KEY_0				= 39,
+	MLX_KEY_RETURN			= 40,
+	MLX_KEY_ENTER			= 40,
+	MLX_KEY_ESCAPE			= 41,
+	MLX_KEY_BACKSPACE		= 42,
+	MLX_KEY_TAB				= 43,
+	MLX_KEY_SPACE			= 44,
+	MLX_KEY_MINUS			= 45,
+	MLX_KEY_EQUALS			= 46,
+	MLX_KEY_LEFTBRACKET		= 47,
+	MLX_KEY_RIGHTBRACKET	= 48,
+	MLX_KEY_BACKSLASH		= 49,
+	MLX_KEY_SEMICOLON		= 51,
+	MLX_KEY_APOSTROPHE		= 52,
+	MLX_KEY_GRAVE			= 53,
+	MLX_KEY_COMMA			= 54,
+	MLX_KEY_PERIOD			= 55,
+	MLX_KEY_SLASH			= 56,
+	MLX_KEY_CAPSLOCK		= 57,
+	MLX_KEY_F1				= 58,
+	MLX_KEY_F2				= 59,
+	MLX_KEY_F3				= 60,
+	MLX_KEY_F4				= 61,
+	MLX_KEY_F5				= 62,
+	MLX_KEY_F6				= 63,
+	MLX_KEY_F7				= 64,
+	MLX_KEY_F8				= 65,
+	MLX_KEY_F9				= 66,
+	MLX_KEY_F10				= 67,
+	MLX_KEY_F11				= 68,
+	MLX_KEY_F12				= 69,
+	MLX_KEY_PRINTSCREEN		= 70,
+	MLX_KEY_SCROLLLOCK		= 71,
+	MLX_KEY_PAUSE			= 72,
+	MLX_KEY_INSERT			= 73,
+	MLX_KEY_HOME			= 74,
+	MLX_KEY_PAGEUP			= 75,
+	MLX_KEY_DELETE			= 76,
+	MLX_KEY_END				= 77,
+	MLX_KEY_PAGEDOWN		= 78,
+	MLX_KEY_RIGHT			= 79,
+	MLX_KEY_LEFT			= 80,
+	MLX_KEY_DOWN			= 81,
+	MLX_KEY_UP				= 82,
+	MLX_KEY_NUMLOCKCLEAR	= 83,
+	MLX_KEY_KP_DIVIDE		= 84,
+	MLX_KEY_KP_MULTIPLY		= 85,
+	MLX_KEY_KP_MINUS		= 86,
+	MLX_KEY_KP_PLUS			= 87,
+	MLX_KEY_KP_ENTER		= 88,
+	MLX_KEY_KP_1			= 89,
+	MLX_KEY_KP_2			= 90,
+	MLX_KEY_KP_3			= 91,
+	MLX_KEY_KP_4			= 92,
+	MLX_KEY_KP_5			= 93,
+	MLX_KEY_KP_6			= 94,
+	MLX_KEY_KP_7			= 95,
+	MLX_KEY_KP_8			= 96,
+	MLX_KEY_KP_9			= 97,
+	MLX_KEY_KP_0			= 98,
+	MLX_KEY_KP_PERIOD		= 99,
+	MLX_KEY_LCTRL			= 224,
+	MLX_KEY_LSHIFT			= 225,
+	MLX_KEY_LALT			= 226,
+	MLX_KEY_LGUI			= 227,
+	MLX_KEY_RCTRL			= 228,
+	MLX_KEY_RSHIFT			= 229,
+	MLX_KEY_RALT			= 230,
+	MLX_KEY_RGUI			= 231
+} mlx_key_codes;
+
+/**
+ * @brief           Event codes for mouse buttons
+ */
+typedef enum mlx_mouse_code
+{
+	MLX_MOUSE_LEFT			= 1,
+	MLX_MOUSE_MIDDLE		= 2,
+	MLX_MOUSE_RIGHT			= 3,
+	MLX_MOUSE_4				= 4,
+	MLX_MOUSE_5				= 5,
+} mlx_mouse_code;
+
+/**
+ * @brief           Event codes for window events
+ */
+typedef enum mlx_window_code
+{
+	MLX_WINDOW_CLOSE		= 0,
+	MLX_WINDOW_MOVED		= 1,
+	MLX_WINDOW_MINIMIZED	= 2,
+	MLX_WINDOW_MAXIMIZED	= 3,
+	MLX_WINDOW_ENTER		= 4,
+	MLX_WINDOW_FOCUS		= 5,
+	MLX_WINDOW_LEAVE		= 6,
+	MLX_WINDOW_UNFOCUS		= 7,
+	MLX_WINDOW_SIZE_CHANGED	= 8,
+	MLX_WINDOW_RESIZED		= 9,
+	MLX_WINDOW_RESTORED		= 11
+} mlx_window_code;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

includes/mlx_profile.h

@@ -83,6 +83,25 @@
 	#define MLX_API
 #endif
 
+#define MLX_NO_DEPRECATE
+#ifdef MLX_NO_DEPRECATE
+	#define MLX_DEPRECATED(msg)
+#elif defined(__has_c_attribute)
+	#if __has_c_attribute(deprecated)
+		#define MLX_DEPRECATED(msg) [[deprecated(msg)]]
+	#endif
+#endif
+
+#ifndef MLX_DEPRECATED
+	#if defined(__GNUC__) || defined(__clang__)
+		#define MLX_DEPRECATED(msg) __attribute__((deprecated(msg)))
+	#elif defined(_MSC_VER)
+		#define MLX_DEPRECATED(msg) __declspec(deprecated(msg))
+	#else
+		#define MLX_DEPRECATED(msg)
+	#endif
+#endif
+
 #if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
 	#define MLX_FUNC_SIG __PRETTY_FUNCTION__
 #elif defined(__DMC__) && (__DMC__ >= 0x810)

meson.build

@@ -1,12 +1,15 @@
 project('MacroLibX',
   ['c', 'cpp'],
-  version : '2.2.4',
+  version : '2.3.0',
   license : 'MIT',
-   meson_version : '>= 1.9.0',
-  default_options : ['warning_level=2', 'optimization=3', 'cpp_std=c++20'])
+  meson_version : '>= 0.63.0',
+  default_options : [
+    'warning_level=2',
+    'optimization=3',
+    'cpp_std=c++20',
+  ]
+)
 
-add_project_arguments('-Wno-error=', language : 'c')
-add_project_arguments('-fPIC', language : 'c')
 add_project_arguments('-DSDL_MAIN_HANDLED', language : 'c')
 
 if get_option('graphics_memory_dump')
@@ -25,15 +28,14 @@ if get_option('disable_all_safeties')
   add_project_arguments('-DDISABLE_ALL_SAFETIES', language : 'c')
 endif
 
-includes_directories = [
-  include_directories('includes'),
-  include_directories('runtime/Includes'),
-  include_directories('runtime/Sources'),
-  include_directories('third_party'),
-]
+includes_directories = include_directories(
+  'includes',
+  'runtime/Includes',
+  'runtime/Sources',
+  'third_party',
+)
 
-sources = [
-  files(
+sources = files(
     'runtime/Sources/Core/Application.cpp',
     'runtime/Sources/Core/Bridge.cpp',
     'runtime/Sources/Core/EventBus.cpp',
@@ -66,9 +68,8 @@ sources = [
     'runtime/Sources/Renderer/RenderCore.cpp',
     'runtime/Sources/Renderer/Renderer.cpp',
     'runtime/Sources/Renderer/SceneRenderer.cpp',
-    'runtime/Sources/Renderer/Swapchain.cpp'
+    'runtime/Sources/Renderer/Swapchain.cpp',
 )
-]
 
 mlx_headers = [
   'includes/mlx.h',
@@ -78,9 +79,7 @@ mlx_headers = [
 
 install_headers(mlx_headers)
 
-deps = [
-  dependency('sdl2'),
-]
+deps = dependency('sdl2')
 
 libmlx = library('mlx',
   sources,

runtime/Includes/Core/Application.h

@@ -23,7 +23,7 @@ namespace mlx
 
 			inline void OnEvent(mlx_window win, int event, void(*f)(int, void*), void* param) noexcept;
 
-			inline mlx_window NewGraphicsSuport(const mlx_window_create_info* info);
+			inline mlx_window NewGraphicsSupport(const mlx_window_create_info* info);
 			inline NonOwningPtr<GraphicsSupport> GetGraphicsSupport(mlx_window win);
 			inline void DestroyGraphicsSupport(mlx_window win);
 

runtime/Includes/Core/Application.inl

@@ -60,7 +60,7 @@ namespace mlx
 		m_fps.SetMaxFPS(fps);
 	}
 
-	mlx_window Application::NewGraphicsSuport(const mlx_window_create_info* info)
+	mlx_window Application::NewGraphicsSupport(const mlx_window_create_info* info)
 	{
 		MLX_PROFILE_FUNCTION();
 		if(!info)
@@ -68,6 +68,11 @@ namespace mlx
 			Error("invalid window create info (NULL)");
 			return nullptr;
 		}
+		if (info->title == nullptr)
+		{
+			Error("invalid window title (NULL)");
+			return nullptr;
+		}
 
 		mlx_window window;
 		try { window = new mlx_window_handler; }

runtime/Includes/Core/Enums.h

@@ -19,9 +19,10 @@ namespace mlx
 
 	enum class Event
 	{
-		ResizeEventCode = 56,
-		FrameBeginEventCode = 57,
-		FatalErrorEventCode = 168,
+		ResizeEventCode = 1,
+		SwapchainResizeEventCode,
+		FrameBeginEventCode,
+		FatalErrorEventCode,
 
 		EndEnum
 	};

runtime/Includes/Core/Fps.h

@@ -1,26 +1,30 @@
 #ifndef __MLX_FPS__
 #define __MLX_FPS__
 
+#include <chrono>
+
 namespace mlx
 {
+	typedef std::chrono::steady_clock fps_clock;
+
 	class FpsManager
 	{
 		public:
 			FpsManager() = default;
 
 			void Init();
-			bool Update();
-			inline void SetMaxFPS(std::uint32_t fps) noexcept { m_max_fps = fps; m_ns = 1000000000.0 / fps; }
+			void WaitUntilNextFrame();
+			inline void SetMaxFPS(std::uint32_t fps) noexcept { m_target_delta = fps_clock::duration(std::chrono::seconds(1)) / fps;}
 
 			~FpsManager() = default;
 
 		private:
-			double m_ns = 1000000000.0 / 1'337'000.0;
-			std::int64_t m_fps_before = 0;
-			std::int64_t m_fps_now = 0;
-			std::int64_t m_timer = 0;
-			std::uint32_t m_max_fps = 1'337'000;
-			std::uint32_t m_fps_elapsed_time = 0;
+			fps_clock::time_point m_current_time;
+			fps_clock::time_point m_target_time;
+			fps_clock::time_point m_last_time_record;
+			fps_clock::duration m_delta_time = fps_clock::duration().zero();
+			fps_clock::duration m_target_delta = fps_clock::duration().zero();
+			fps_clock::duration m_sleep_margin = std::chrono::microseconds(200);
 	};
 }
 

runtime/Includes/Core/Graphics.h

@@ -28,7 +28,7 @@ namespace mlx
 			void PixelPutArray(int x, int y, mlx_color* color, std::size_t pixels_size) noexcept;
 			void PixelPutRegion(int x, int y, int w, int h, mlx_color* color) noexcept;
 			void StringPut(int x, int y, mlx_color color, std::string str);
-			void TexturePut(NonOwningPtr<class Texture> texture, int x, int y, float scale_x, float scale_y, float angle);
+			void TexturePut(NonOwningPtr<class Texture> texture, float x, float y, float scale_x, float scale_y, float angle);
 
 			inline void TryEraseSpritesInScene(NonOwningPtr<Texture> texture) noexcept;
 

runtime/Includes/Core/Profiler.h

@@ -47,7 +47,6 @@ namespace mlx
 
 			std::unordered_map<std::string, std::pair<std::size_t, ProfileResult>> m_profile_data;
 			std::ofstream m_output_stream;
-			std::mutex m_mutex;
 			bool m_runtime_session_began = false;
 	};
 

runtime/Includes/Core/SDLManager.h

@@ -3,6 +3,7 @@
 
 #include <mlx.h>
 #include <Maths/Vec2.h>
+#include <Renderer/Image.h>
 
 namespace mlx
 {
@@ -20,13 +21,13 @@ namespace mlx
 			void SetInputBinding(std::function<void(SDL_Event*)> functor);
 
 			VkSurfaceKHR CreateVulkanSurface(Handle window, VkInstance instance) const noexcept;
-			std::vector<const char*> GetRequiredVulkanInstanceExtentions(Handle window) const noexcept;
 			Vec2ui GetVulkanDrawableSize(Handle window) const noexcept;
 			void MoveMouseOnWindow(Handle window, int x, int y) const noexcept;
 			void GetScreenSizeWindowIsOn(Handle window, int* x, int* y) const noexcept;
 			void SetWindowPosition(Handle window, int x, int y) const noexcept;
 			void SetWindowSize(Handle window, int x, int y) const noexcept;
 			void SetWindowTitle(Handle window, std::string_view title) const noexcept;
+			void SetWindowIcon(Handle window, NonOwningPtr<Texture> texture) const noexcept;
 			void SetWindowFullscreen(Handle window, bool enable) const noexcept;
 			void SetWindowMaxSize(Handle window, int x, int y) const noexcept;
 			void SetWindowMinSize(Handle window, int x, int y) const noexcept;

runtime/Includes/Graphics/PutPixelManager.h

@@ -8,7 +8,7 @@ namespace mlx
 	class PutPixelManager
 	{
 		public:
-			PutPixelManager(NonOwningPtr<class Renderer> renderer) : p_renderer(renderer) {}
+			PutPixelManager(NonOwningPtr<class Renderer> renderer);
 
 			// Returns a valid pointer when a new texture has been created
 			NonOwningPtr<Texture> DrawPixel(int x, int y, std::uint64_t draw_layer, mlx_color color);
@@ -20,6 +20,7 @@ namespace mlx
 
 		private:
 			NonOwningPtr<Texture> GetLayer(std::uint64_t draw_layer, bool& is_newlayer);
+			std::unique_ptr<Texture> NewTexture();
 
 		private:
 			std::unordered_map<std::uint64_t, NonOwningPtr<Texture>> m_placements;

runtime/Includes/Platform/Window.h

@@ -4,6 +4,7 @@
 #include <mlx.h>
 #include <Maths/Vec2.h>
 #include <Core/SDLManager.h>
+#include <Renderer/Image.h>
 
 namespace mlx
 {
@@ -24,6 +25,7 @@ namespace mlx
 			MLX_FORCEINLINE void SetPosition(int x, int y) { SDLManager::Get().SetWindowPosition(p_window, x, y); }
 			MLX_FORCEINLINE void SetSize(int x, int y) { SDLManager::Get().SetWindowSize(p_window, x, y); m_width = x; m_height = y; }
 			MLX_FORCEINLINE void SetTitle(std::string title) { SDLManager::Get().SetWindowTitle(p_window, title); m_name = std::move(title); }
+			MLX_FORCEINLINE void SetIcon(NonOwningPtr<Texture> texture) {SDLManager::Get().SetWindowIcon(p_window, texture); }
 			MLX_FORCEINLINE void SetFullscreen(bool enable) { SDLManager::Get().SetWindowFullscreen(p_window, enable); }
 			MLX_FORCEINLINE void SetMaxSize(int x, int y) { SDLManager::Get().SetWindowMaxSize(p_window, x, y); }
 			MLX_FORCEINLINE void SetMinSize(int x, int y) { SDLManager::Get().SetWindowMinSize(p_window, x, y); }
@@ -35,7 +37,6 @@ namespace mlx
 			MLX_FORCEINLINE void GetSize(int* x, int* y) { *x = GetWidth(); *y = GetHeight(); }
 
 			MLX_FORCEINLINE VkSurfaceKHR CreateVulkanSurface(VkInstance instance) const noexcept { return SDLManager::Get().CreateVulkanSurface(p_window, instance); }
-			MLX_FORCEINLINE std::vector<const char*> GetRequiredVulkanInstanceExtentions() const noexcept { return SDLManager::Get().GetRequiredVulkanInstanceExtentions(p_window); }
 			MLX_FORCEINLINE Vec2ui GetVulkanDrawableSize() const noexcept { return SDLManager::Get().GetVulkanDrawableSize(p_window); }
 
 			[[nodiscard]] inline Handle GetRawHandle() const noexcept { return p_window; }

runtime/Includes/PreCompiled.h

@@ -25,12 +25,12 @@
 	#error Failed to find SDL2 headers
 #endif
 
-#if __has_include(<SDL2/SDL_vulkan.h>)
-	#include <SDL2/SDL_vulkan.h>
-#elif __has_include(<SDL_vulkan.h>)
-	#include <SDL_vulkan.h>
+#if __has_include(<SDL2/SDL_syswm.h>)
+	#include <SDL2/SDL_syswm.h>
+#elif __has_include(<SDL_syswm.h>)
+	#include <SDL_syswm.h>
 #else
-	#error Failed to find SDL2 Vulkan headers
+	#error Failed to find SDL2 SysWMinfo
 #endif
 
 #include <functional>

runtime/Includes/Renderer/Image.h

@@ -86,10 +86,19 @@ namespace mlx
 			void SetPixel(int x, int y, mlx_color color) noexcept;
 			void SetRegion(int x, int y, int w, int h, mlx_color* color) noexcept;
 			void SetLinearRegion(int x, int y, std::size_t len, mlx_color* color) noexcept;
+			void SetRectangle(int x, int y, int w, int h, mlx_color color) noexcept;
 			mlx_color GetPixel(int x, int y) noexcept;
 			void GetRegion(int x, int y, int w, int h, mlx_color* dst) noexcept;
 			void Clear(VkCommandBuffer cmd, Vec4f color) override;
+			void CopyTo(Texture& other);
+			void Resize(std::uint32_t width, std::uint32_t height);
 
+			void Swap(Texture& texture) noexcept;
+
+			mlx_color* GetBufferCopy() noexcept;
+
+			// If a valid cmd buffer is passed, this function takes ownership and makes it invalid after
+			void SyncCPUBuffer(VkCommandBuffer cmd = VK_NULL_HANDLE);
 			void Update(VkCommandBuffer cmd);
 
 			~Texture() override { Destroy(); }

runtime/Includes/Renderer/Vulkan/VulkanDefs.h

@@ -123,5 +123,41 @@
 		MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR)
 		MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR)
 		MLX_VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR)
+
+		#ifdef VK_USE_PLATFORM_ANDROID_KHR
+			#ifdef VK_KHR_android_surface
+				MLX_VULKAN_INSTANCE_FUNCTION(vkCreateAndroidSurfaceKHR)
+			#endif
+		#endif
+		
+		#ifdef VK_USE_PLATFORM_XCB_KHR
+			#ifdef VK_KHR_xcb_surface
+				MLX_VULKAN_INSTANCE_FUNCTION(vkCreateXcbSurfaceKHR)
+			#endif
+		#endif
+		
+		#ifdef VK_USE_PLATFORM_XLIB_KHR
+			#ifdef VK_KHR_xlib_surface
+				MLX_VULKAN_INSTANCE_FUNCTION(vkCreateXlibSurfaceKHR)
+			#endif
+		#endif
+		
+		#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+			#ifdef VK_KHR_wayland_surface
+				MLX_VULKAN_INSTANCE_FUNCTION(vkCreateWaylandSurfaceKHR)
+			#endif
+		#endif
+		
+		#ifdef VK_USE_PLATFORM_WIN32_KHR
+			#ifdef VK_KHR_win32_surface
+				MLX_VULKAN_INSTANCE_FUNCTION(vkCreateWin32SurfaceKHR)
+			#endif
+		#endif
+		
+		#ifdef VK_USE_PLATFORM_METAL_EXT
+			#ifdef VK_EXT_metal_surface
+				MLX_VULKAN_INSTANCE_FUNCTION(vkCreateMetalSurfaceEXT)
+			#endif
+		#endif
 	#endif
 #endif

runtime/Includes/Utils/Buffer.h

@@ -1,6 +1,8 @@
 #ifndef __MLX_CPU_BUFFER__
 #define __MLX_CPU_BUFFER__
 
+#include <PreCompiled.h>
+
 namespace mlx
 {
 	class CPUBuffer

runtime/Sources/Core/Application.cpp

@@ -33,8 +33,7 @@ namespace mlx
 
 		while(m_in.IsRunning())
 		{
-			if(!m_fps.Update())
-				continue;
+			m_fps.WaitUntilNextFrame();
 
 			m_in.FetchInputs();
 

runtime/Sources/Core/Bridge.cpp

@@ -45,9 +45,8 @@ extern "C"
 	void mlx_set_fps_goal(mlx_context mlx, int fps)
 	{
 		MLX_CHECK_APPLICATION_POINTER(mlx);
-		if(fps < 0)
-			mlx::Error("You cannot set a negative FPS cap (nice try)");
-		else
+		if(fps <= 0)
+			fps = -1;
 		mlx->app->SetFPSCap(static_cast<std::uint32_t>(fps));
 	}
 
@@ -62,7 +61,7 @@ extern "C"
 	mlx_window mlx_new_window(mlx_context mlx, const mlx_window_create_info* info)
 	{
 		MLX_CHECK_APPLICATION_POINTER(mlx);
-		return mlx->app->NewGraphicsSuport(info);
+		return mlx->app->NewGraphicsSupport(info);
 	}
 
 	void mlx_destroy_window(mlx_context mlx, mlx_window win)
@@ -92,12 +91,29 @@ extern "C"
 	void mlx_set_window_title(mlx_context mlx, mlx_window win, const char* title)
 	{
 		MLX_CHECK_APPLICATION_POINTER(mlx);
+		if (title == nullptr)
+		{
+			mlx::Error("invalid window title (NULL)");
+			return;
+		}
 		mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
 		if(!gs && !gs->HasWindow())
 			return;
 		gs->GetWindow()->SetTitle(title);
 	}
 
+	void mlx_set_window_icon(mlx_context mlx, mlx_window win, mlx_image image)
+	{
+		MLX_CHECK_APPLICATION_POINTER(mlx);
+		mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);
+		if(!gs && !gs->HasWindow())
+			return;
+		mlx::NonOwningPtr<mlx::Texture> texture = mlx->app->GetTexture(image);
+		if(!texture)
+			return;
+		gs->GetWindow()->SetIcon(texture);
+	}
+
 	void mlx_set_window_fullscreen(mlx_context mlx, mlx_window win, bool enable)
 	{
 		MLX_CHECK_APPLICATION_POINTER(mlx);
@@ -238,6 +254,15 @@ extern "C"
 			mlx::Error("Image loader: not a valid file format '%'", filename);
 			return nullptr;
 		}
+
+		{
+			std::ifstream stream(file, std::ios::binary);
+			if(!stream.is_open())
+			{
+				mlx::Error("Image loader: failed to open file '%'", filename);
+				return nullptr;
+			}
+		}
 		return mlx->app->NewStbTexture(filename, width, height);
 	}
 
@@ -304,12 +329,29 @@ extern "C"
 			mlx::Error("Font loader: filepath is NULL");
 			return;
 		}
+
 		std::filesystem::path file(filepath);
-		if(std::strcmp(filepath, "default") != 0 && file.extension() != ".ttf" && file.extension() != ".tte")
+		if (std::strcmp(filepath, "default") != 0 && !std::filesystem::exists(file))
+		{
+			mlx::Error("TTF loader: unable to find file '%'", filepath);
+			return;
+		}
+
+		if(std::strcmp(filepath, "default") != 0)
+		{
+			if(file.extension() != ".ttf" && file.extension() != ".tte")
 			{
 				mlx::Error("TTF loader: not a truetype font file '%'", filepath);
 				return;
 			}
+			std::ifstream stream(file, std::ios::binary);
+			if(!stream.is_open())
+			{
+				mlx::Error("TTF loader: failed to open font file '%'", filepath);
+				return;
+			}
+		}
+
 		if(std::strcmp(filepath, "default") == 0)
 			mlx->app->LoadFont(file, 6.f);
 		else
@@ -324,12 +366,29 @@ extern "C"
 			mlx::Error("Font loader: filepath is NULL");
 			return;
 		}
+
 		std::filesystem::path file(filepath);
-		if(std::strcmp(filepath, "default") != 0 && file.extension() != ".ttf" && file.extension() != ".tte")
+		if (std::strcmp(filepath, "default") != 0 && !std::filesystem::exists(file))
+		{
+			mlx::Error("TTF loader: unable to find file '%'", filepath);
+			return;
+		}
+
+		if(std::strcmp(filepath, "default") != 0)
+		{
+			if(file.extension() != ".ttf" && file.extension() != ".tte")
 			{
 				mlx::Error("TTF loader: not a truetype font file '%'", filepath);
 				return;
 			}
+			std::ifstream stream(file, std::ios::binary);
+			if(!stream.is_open())
+			{
+				mlx::Error("TTF loader: failed to open font file '%'", filepath);
+				return;
+			}
+		}
+
 		mlx->app->LoadFont(file, scale);
 	}
 
@@ -398,6 +457,15 @@ extern "C"
 		gs->PixelPutRegion(x, y, w, h, pixels);
 	}
 
+	void mlx_set_image_rectangle(mlx_context mlx, mlx_image image, int x, int y, int w, int h, mlx_color color)
+	{
+		MLX_CHECK_APPLICATION_POINTER(mlx);
+		mlx::NonOwningPtr<mlx::Texture> texture = mlx->app->GetTexture(image);
+		if(!texture)
+			return;
+		texture->SetRectangle(x, y, w, h, color);
+	}
+
 	void mlx_get_image_region(mlx_context mlx, mlx_image image, int x, int y, int w, int h, mlx_color* dst)
 	{
 		MLX_CHECK_APPLICATION_POINTER(mlx);
@@ -416,7 +484,7 @@ extern "C"
 		texture->SetRegion(x, y, w, h, 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)
+	void mlx_put_transformed_image_to_window(mlx_context mlx, mlx_window win, mlx_image image, float x, float y, float scale_x, float scale_y, float angle)
 	{
 		MLX_CHECK_APPLICATION_POINTER(mlx);
 		mlx::NonOwningPtr<mlx::GraphicsSupport> gs = mlx->app->GetGraphicsSupport(win);

runtime/Sources/Core/Fps.cpp

@@ -1,30 +1,37 @@
 #include <PreCompiled.h>
 #include <Core/Fps.h>
 
+#ifndef __APPLE__
+#include <emmintrin.h>
+#endif
+
 namespace mlx
 {
 	void FpsManager::Init()
 	{
-		m_timer = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
-		m_fps_before = m_timer;
-		m_fps_now = m_timer;
+		m_current_time = fps_clock::now();
+		m_target_time = m_current_time + m_target_delta;
 	}
 
-	bool FpsManager::Update()
+	void FpsManager::WaitUntilNextFrame()
 	{
-		using namespace std::chrono_literals;
-		m_fps_now = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
-
-		if(std::chrono::duration<std::uint64_t>{m_fps_now - m_timer} >= 1s)
-			m_timer += m_fps_now;
-
-		m_fps_elapsed_time = m_fps_now - m_fps_before;
-		if(m_fps_elapsed_time >= m_ns)
+		m_current_time = fps_clock::now();
+		if(m_current_time < m_target_time)
 		{
-			m_fps_before += m_ns;
-			return true;
-		}
-		std::this_thread::sleep_for(std::chrono::duration<double, std::nano>(m_ns - 1));
-		return false;
+			std::this_thread::sleep_until(m_target_time - m_sleep_margin);
+			m_current_time = fps_clock::now();
+			while (m_current_time < m_target_time)
+			{
+				#ifndef __APPLE__
+					_mm_pause(); // reduces CPU usage on x86 without yielding
+				#endif
+				m_current_time = fps_clock::now();
+			}
+		}
+		else if (m_target_time < m_current_time - m_target_delta * 4)
+			m_target_time = m_current_time;
+		m_target_time += m_target_delta;
+		m_delta_time = m_current_time - m_last_time_record;
+		m_last_time_record = m_current_time;
 	}
 }

runtime/Sources/Core/Graphics.cpp

@@ -136,7 +136,7 @@ namespace mlx
 			p_scene->BringToDrawLayer(text.Get(), m_draw_layer);
 	}
 
-	void GraphicsSupport::TexturePut(NonOwningPtr<Texture> texture, int x, int y, float scale_x, float scale_y, float angle)
+	void GraphicsSupport::TexturePut(NonOwningPtr<Texture> texture, float x, float y, float scale_x, float scale_y, float angle)
 	{
 		MLX_PROFILE_FUNCTION();
 		NonOwningPtr<Sprite> sprite = p_scene->GetSpriteFromTexturePositionScaleRotation(texture, Vec2f{ static_cast<float>(x), static_cast<float>(y) }, scale_x, scale_y, angle);

runtime/Sources/Core/Profiler.cpp

@@ -8,7 +8,6 @@ namespace mlx
 
 	void Profiler::BeginRuntimeSession()
 	{
-		std::lock_guard lock(m_mutex);
 		if(m_runtime_session_began)
 			return;
 		m_output_stream.open("./runtime_profile.mlx.json", std::ofstream::out | std::ofstream::trunc);
@@ -22,7 +21,6 @@ namespace mlx
 
 	void Profiler::AppendProfileData(ProfileResult&& result)
 	{
-		std::lock_guard lock(m_mutex);
 		auto it = m_profile_data.find(result.name);
 		if(it != m_profile_data.end())
 		{
@@ -49,7 +47,6 @@ namespace mlx
 
 	void Profiler::EndRuntimeSession()
 	{
-		std::lock_guard lock(m_mutex);
 		if(!m_runtime_session_began)
 			return;
 		for(auto& [_, pair] : m_profile_data)

runtime/Sources/Core/SDLManager.cpp

@@ -1,3 +1,5 @@
+#include "Utils/Buffer.h"
+#include "mlx.h"
 #include <PreCompiled.h>
 #include <Core/SDLManager.h>
 #include <Core/Memory.h>
@@ -43,7 +45,7 @@ namespace mlx
 		Internal::WindowInfos* infos = new Internal::WindowInfos;
 		Verify(infos != nullptr, "SDL: window allocation failed");
 
-		std::uint32_t flags = SDL_WINDOW_VULKAN;
+		std::uint32_t flags = 0;
 		if(hidden)
 			flags |= SDL_WINDOW_HIDDEN;
 		else
@@ -56,7 +58,12 @@ namespace mlx
 		infos->window = SDL_CreateWindow(info->title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, info->width, info->height, flags);
 		if(!infos->window)
 			FatalError("SDL: unable to open a new window; %", SDL_GetError());
-		infos->icon = SDL_CreateRGBSurfaceFrom(static_cast<void*>(logo_mlx), logo_mlx_width, logo_mlx_height, 32, 4 * logo_mlx_width, Rmask(), Gmask(), Bmask(), Amask());
+
+		mlx_color* buffer = new mlx_color[logo_mlx_size];
+		std::memcpy(buffer, logo_mlx, logo_mlx_size);
+		infos->icon = SDL_CreateRGBSurfaceFrom(buffer, logo_mlx_width, logo_mlx_height, 32, logo_mlx_width * 4, Rmask(), Gmask(), Bmask(), Amask());
+		if(!infos->icon)
+			FatalError("SDL: unable to create a window icon; %", SDL_GetError());
 		SDL_SetWindowIcon(infos->window, infos->icon);
 
 		m_windows_registry.insert(infos);
@@ -74,7 +81,10 @@ namespace mlx
 		if(infos->window != nullptr)
 			SDL_DestroyWindow(infos->window);
 		if(infos->icon != nullptr)
+		{
+			delete[] reinterpret_cast<mlx_color*>(infos->icon->pixels);
 			SDL_FreeSurface(infos->icon);
+		}
 
 		m_windows_registry.erase(infos);
 		delete infos;
@@ -88,28 +98,38 @@ namespace mlx
 
 	VkSurfaceKHR SDLManager::CreateVulkanSurface(Handle window, VkInstance instance) const noexcept
 	{
-		VkSurfaceKHR surface;
-		if(!SDL_Vulkan_CreateSurface(static_cast<Internal::WindowInfos*>(window)->window, instance, &surface))
-			FatalError("SDL: could not create a Vulkan surface; %", SDL_GetError());
-		return surface;
-	}
+		SDL_SysWMinfo info;
+		SDL_VERSION(&info.version);
+		if(SDL_GetWindowWMInfo(static_cast<Internal::WindowInfos*>(window)->window, &info) != SDL_TRUE)
+			FatalError("SDL Manager: cannot retrieve window informations");
 
-	std::vector<const char*> SDLManager::GetRequiredVulkanInstanceExtentions(Handle window) const noexcept
+		switch(info.subsystem)
 		{
-		std::uint32_t count;
-		if(!SDL_Vulkan_GetInstanceExtensions(static_cast<Internal::WindowInfos*>(window)->window, &count, nullptr))
-			FatalError("SDL Manager: could not retrieve Vulkan instance extensions");
-		std::vector<const char*> extensions(count);
-		if(!SDL_Vulkan_GetInstanceExtensions(static_cast<Internal::WindowInfos*>(window)->window, &count, extensions.data()))
-			FatalError("SDL Manager: could not retrieve Vulkan instance extensions");
-		extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
-		return extensions;
+			#ifdef SDL_VIDEO_DRIVER_WINDOWS
+				case SDL_SYSWM_WINDOWS: return kvfCreateSurfaceKHR(instance, KVF_SURFACE_WINDOWS, static_cast<void*>(info.info.win.hinstance), static_cast<void*>(info.info.win.window));
+			#endif
+			#ifdef SDL_VIDEO_DRIVER_X11
+				case SDL_SYSWM_X11: return kvfCreateSurfaceKHR(instance, KVF_SURFACE_XLIB, static_cast<void*>(info.info.x11.display), static_cast<void*>(&info.info.x11.window));
+			#endif
+			#ifdef SDL_VIDEO_DRIVER_COCOA
+				case SDL_SYSWM_COCOA: FatalError("SDL Manager: Vulkan surfaces over Metal are not supported yet. Please fill an issue here https://github.com/seekrs/MacroLibX/issues/new");
+			#endif
+			#ifdef SDL_VIDEO_DRIVER_WAYLAND
+				case SDL_SYSWM_WAYLAND: return kvfCreateSurfaceKHR(instance, KVF_SURFACE_WAYLAND, static_cast<void*>(info.info.wl.display), static_cast<void*>(info.info.wl.surface));
+			#endif
+			#ifdef SDL_VIDEO_DRIVER_ANDROID
+				case SDL_SYSWM_ANDROID: return kvfCreateSurfaceKHR(instance, KVF_SURFACE_ANDROID, nullptr, static_cast<void*>(info.info.android.window));
+			#endif
+
+			default : FatalError("SDL Manager: unsupported windowing system"); break;
+		}
+		return VK_NULL_HANDLE;
 	}
 
 	Vec2ui SDLManager::GetVulkanDrawableSize(Handle window) const noexcept
 	{
 		Vec2i extent;
-		SDL_Vulkan_GetDrawableSize(static_cast<Internal::WindowInfos*>(window)->window, &extent.x, &extent.y);
+		SDL_GetWindowSize(static_cast<Internal::WindowInfos*>(window)->window, &extent.x, &extent.y);
 		return Vec2ui{ extent };
 	}
 
@@ -142,6 +162,21 @@ namespace mlx
 		SDL_SetWindowTitle(static_cast<Internal::WindowInfos*>(window)->window, title.data());
 	}
 
+	void SDLManager::SetWindowIcon(Handle window, NonOwningPtr<Texture> texture) const noexcept
+	{
+		Internal::WindowInfos* infos = static_cast<Internal::WindowInfos*>(window);
+		if(infos->icon != nullptr)
+		{
+			delete[] reinterpret_cast<mlx_color*>(infos->icon->pixels);
+			SDL_FreeSurface(infos->icon);
+		}
+
+		int width = texture->GetWidth(), height = texture->GetHeight();
+
+		infos->icon = SDL_CreateRGBSurfaceFrom(texture->GetBufferCopy(), width, height, 32, width * 4, Rmask(), Gmask(), Bmask(), Amask());
+		SDL_SetWindowIcon(infos->window, infos->icon);
+	}
+
 	void SDLManager::SetWindowFullscreen(Handle window, bool enable) const noexcept
 	{
 		SDL_SetWindowFullscreen(static_cast<Internal::WindowInfos*>(window)->window, (enable ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));
@@ -266,6 +301,8 @@ namespace mlx
 						case SDL_WINDOWEVENT_LEAVE: functor(MLX_WINDOW_EVENT, id, 6); break;
 						case SDL_WINDOWEVENT_FOCUS_LOST: functor(MLX_WINDOW_EVENT, id, 7); break;
 						case SDL_WINDOWEVENT_SIZE_CHANGED: functor(MLX_WINDOW_EVENT, id, 8); break;
+						case SDL_WINDOWEVENT_RESIZED: functor(MLX_WINDOW_EVENT, id, 9); break;
+						case SDL_WINDOWEVENT_RESTORED: functor(MLX_WINDOW_EVENT, id, 11); break;
 
 						default : break;
 					}
@@ -284,6 +321,7 @@ namespace mlx
 	{
 		if(m_drop_sdl_responsability)
 			return;
+
 		SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_EVENTS);
 		SDL_Quit();
 		s_instance = nullptr;

runtime/Sources/Graphics/PutPixelManager.cpp

@@ -6,6 +6,29 @@
 
 namespace mlx
 {
+	PutPixelManager::PutPixelManager(NonOwningPtr<class Renderer> renderer) : p_renderer(renderer)
+	{
+		MLX_PROFILE_FUNCTION();
+		std::function<void(const EventBase&)> functor = [this](const EventBase& event)
+		{
+			// Suboptimal for multi-windows applications
+			if(event.What() == Event::ResizeEventCode)
+			{
+				VkExtent2D extent{ .width = 0, .height = 0 };
+				if(p_renderer->GetWindow())
+					extent = kvfGetSwapchainImagesSize(p_renderer->GetSwapchain().Get());
+				else if(p_renderer->GetRenderTarget())
+					extent = VkExtent2D{ .width = p_renderer->GetRenderTarget()->GetWidth(), .height = p_renderer->GetRenderTarget()->GetHeight() };
+				else
+					FatalError("a renderer was created without window nor render target attached (wtf!?)");
+
+				for(auto& texture : m_textures)
+					texture->Resize(extent.width, extent.height);
+			}
+		};
+		EventBus::RegisterListener({ functor, "mlx_put_pixel_manager_" + std::to_string(reinterpret_cast<std::uintptr_t>(this)) });
+	}
+
 	NonOwningPtr<Texture> PutPixelManager::DrawPixel(int x, int y, std::uint64_t draw_layer, mlx_color color)
 	{
 		MLX_PROFILE_FUNCTION();
@@ -53,21 +76,8 @@ namespace mlx
 		is_newlayer = true;
 
 		if(m_current_texture_index >= m_textures.size())
-		{
-			VkExtent2D extent{ .width = 0, .height = 0 };
-			if(p_renderer->GetWindow())
-				extent = kvfGetSwapchainImagesSize(p_renderer->GetSwapchain().Get());
-			else if(p_renderer->GetRenderTarget())
-				extent = VkExtent2D{ .width = p_renderer->GetRenderTarget()->GetWidth(), .height = p_renderer->GetRenderTarget()->GetHeight() };
-			else
-				FatalError("a renderer was created without window nor render target attached (wtf)");
+			m_textures.push_back(NewTexture());
 
-			#ifdef DEBUG
-				m_textures.push_back(std::make_unique<Texture>(CPUBuffer{}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_put_pixel_layer_" + std::to_string(m_current_texture_index)));
-			#else
-				m_textures.push_back(std::make_unique<Texture>(CPUBuffer{}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, std::string_view{}));
-			#endif
-		}
 		try
 		{
 			m_placements[draw_layer] = m_textures.at(m_current_texture_index).get();
@@ -83,6 +93,23 @@ namespace mlx
 		}
 	}
 
+	std::unique_ptr<Texture> PutPixelManager::NewTexture()
+	{
+		VkExtent2D extent{ .width = 0, .height = 0 };
+		if(p_renderer->GetWindow())
+			extent = kvfGetSwapchainImagesSize(p_renderer->GetSwapchain().Get());
+		else if(p_renderer->GetRenderTarget())
+			extent = VkExtent2D{ .width = p_renderer->GetRenderTarget()->GetWidth(), .height = p_renderer->GetRenderTarget()->GetHeight() };
+		else
+			FatalError("a renderer was created without window nor render target attached (wtf!?)");
+
+		#ifdef DEBUG
+			return std::make_unique<Texture>(CPUBuffer{}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_put_pixel_layer_" + std::to_string(m_current_texture_index));
+		#else
+			return std::make_unique<Texture>(CPUBuffer{}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, std::string_view{});
+		#endif
+	}
+
 	void PutPixelManager::ResetRenderData()
 	{
 		m_placements.clear();

runtime/Sources/Platform/Inputs.cpp

@@ -8,9 +8,9 @@ namespace mlx
 {
 	namespace Internal
 	{
-		struct ResizeEventBroadcast : public EventBase
+		struct SwapchainResizeEventBroadcast : public EventBase
 		{
-			Event What() const override { return Event::ResizeEventCode; }
+			Event What() const override { return Event::SwapchainResizeEventCode; }
 		};
 	}
 
@@ -23,7 +23,7 @@ namespace mlx
 			if(!m_events_hooks.contains(window_id) || m_events_hooks[window_id][event].empty())
 				return;
 			if(event == MLX_WINDOW_EVENT && code == 8)
-				EventBus::SendBroadcast(Internal::ResizeEventBroadcast{});
+				EventBus::SendBroadcast(Internal::SwapchainResizeEventBroadcast{});
 			for(const auto& hook : m_events_hooks[window_id][event])
 			{
 				if(hook.fn)

runtime/Sources/Renderer/Image.cpp

@@ -1,3 +1,5 @@
+#include "Utils/Buffer.h"
+#include "mlx.h"
 #include <PreCompiled.h>
 #include <Renderer/Image.h>
 #include <Maths/Vec4.h>
@@ -24,7 +26,7 @@
 
 namespace mlx
 {
-	mlx_color ReverseColor(mlx_color color)
+	MLX_FORCEINLINE mlx_color ReverseColor(mlx_color color)
 	{
 		mlx_color reversed_color;
 		reversed_color.r = color.a;
@@ -226,25 +228,34 @@ 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)
-			return;
-		if(w < 0 || h < 0)
+		if(w < 0 || h < 0 || x < -w || y < -h
+			|| x >= static_cast<int>(m_width) || y >= static_cast<int>(m_height))
 			return;
 		if(!m_staging_buffer.has_value())
 			OpenCPUBuffer();
-		for(std::uint32_t i = 0, moving_x = x, moving_y = y;; i++, moving_x++)
+		const int
+			start_x = std::max<int>(x, 0),
+			start_y = std::max<int>(y, 0),
+			start_row = start_y * m_width,
+			start_i = (start_y - y) * w + (start_x - x),
+			end_x = std::min<int>(x + w, m_width),
+			end_y = std::min<int>(y + h, m_height),
+			end_row = end_y * m_width,
+			incr = (x + w) - end_x + (start_x - x);
+		for(int i = start_i, dx = start_x, row = start_row;; i++, dx++)
 		{
-			if(moving_x >= static_cast<std::uint32_t>(x + w) || moving_x >= m_width)
+			if(dx >= end_x)
 			{
-				moving_x = x;
-				moving_y++;
-				if(moving_y >= static_cast<std::uint32_t>(y + h) || moving_y >= m_height)
+				i += incr;
+				dx = start_x;
+				row += m_width;
+				if(row >= end_row)
 					break;
 			}
 			if constexpr(std::endian::native == std::endian::little)
-				m_staging_buffer->GetMap<mlx_color*>()[(moving_y * m_width) + moving_x] = ReverseColor(pixels[i]);
+				m_staging_buffer->GetMap<mlx_color*>()[row + dx] = ReverseColor(pixels[i]);
 			else
-				m_staging_buffer->GetMap<mlx_color*>()[(moving_y * m_width) + moving_x] = pixels[i];
+				m_staging_buffer->GetMap<mlx_color*>()[row + dx] = pixels[i];
 		}
 		m_has_been_modified = true;
 	}
@@ -252,23 +263,55 @@ 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 >= static_cast<int>(m_width) || y >= static_cast<int>(m_height))
 			return;
 		if(!m_staging_buffer.has_value())
 			OpenCPUBuffer();
+		int
+			start = y * m_width + x,
+			dest_start = std::max<int>(start, 0),
+			src_start = dest_start - start,
+			dest_end = std::min<int>(start + len, m_width * m_height);
 		if constexpr(std::endian::native == std::endian::little)
 		{
-			for(std::size_t i = 0; i < len && (y * m_width) + x + i < m_width * m_height; i++)
-				m_staging_buffer->GetMap<mlx_color*>()[(y * m_width) + x + i] = ReverseColor(pixels[i]);
+			for(int i = dest_start, j = src_start; i < dest_end; i++, j++)
+				m_staging_buffer->GetMap<mlx_color*>()[i] = ReverseColor(pixels[j]);
 		}
 		else
 		{
-			std::size_t len_guard;
-			if((y * m_width + x + len) < m_width * m_height)
-				len_guard = len;
+			std::memcpy(
+				&m_staging_buffer->GetMap<mlx_color*>()[dest_start],
+				&pixels[src_start], dest_end - dest_start);
+		}
+		m_has_been_modified = true;
+	}
+
+	void Texture::SetRectangle(int x, int y, int w, int h, mlx_color color) noexcept
+	{
+		MLX_PROFILE_FUNCTION();
+		if(w < 0 || h < 0 || x < -w || y < -h
+			|| x >= static_cast<int>(m_width) || y >= static_cast<int>(m_height))
+			return;
+		if(!m_staging_buffer.has_value())
+			OpenCPUBuffer();
+		const int
+			start_x = std::max<int>(x, 0),
+			start_row = std::max<int>(y, 0) * m_width,
+			end_x = std::min<int>(x + w, m_width),
+			end_row = std::min<int>(y + h, m_height) * m_width;
+		for(int dx = start_x, row = start_row;; dx++)
+		{
+			if(dx >= end_x)
+			{
+				dx = start_x;
+				row += m_width;
+				if(row >= end_row)
+					break;
+			}
+			if constexpr(std::endian::native == std::endian::little)
+				m_staging_buffer->GetMap<mlx_color*>()[row + dx] = ReverseColor(color);
 			else
-				len_guard = len - (m_width * m_height - (y * m_width + x + len));
-			std::memcpy(&m_staging_buffer->GetMap<mlx_color*>()[(y * m_width) + x], pixels, len_guard);
+				m_staging_buffer->GetMap<mlx_color*>()[row + dx] = color;
 		}
 		m_has_been_modified = true;
 	}
@@ -289,23 +332,23 @@ 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(w < 0 || h < 0 || x < 0 || y < 0 || static_cast<std::uint32_t>(x + w) >= m_width || static_cast<std::uint32_t>(y + h) >= m_height)
 			return;
 		if(!m_staging_buffer.has_value())
 			OpenCPUBuffer();
-		for(std::uint32_t i = 0, moving_x = x, moving_y = y;; i++, moving_x++)
+		for(std::uint32_t i = 0, dx = x, row = y * m_width;; i++, dx++)
 		{
-			if(moving_x >= static_cast<std::uint32_t>(x + w) || moving_x >= m_width)
+			if(dx >= m_width)
 			{
-				moving_x = x;
-				moving_y++;
-				if(moving_y >= static_cast<std::uint32_t>(y + h) || moving_y >= m_height)
+				dx = x;
+				row += m_width;
+				if(row >= m_height * m_width)
 					break;
 			}
 			if constexpr(std::endian::native == std::endian::little)
-				dst[i] = ReverseColor(m_staging_buffer->GetMap<mlx_color*>()[(moving_y * m_width) + moving_x]);
+				dst[i] = ReverseColor(m_staging_buffer->GetMap<mlx_color*>()[row + dx]);
 			else
-				dst[i] = m_staging_buffer->GetMap<mlx_color*>()[(moving_y * m_width) + moving_x];
+				dst[i] = m_staging_buffer->GetMap<mlx_color*>()[row + dx];
 		}
 	}
 
@@ -320,16 +363,8 @@ namespace mlx
 			processed_color.g = static_cast<std::uint8_t>(color.g * 255.f);
 			processed_color.b = static_cast<std::uint8_t>(color.b * 255.f);
 			processed_color.a = static_cast<std::uint8_t>(color.a * 255.f);
-			if(processed_color.r == 0 && processed_color.g == 0 && processed_color.b == 0)
-				std::memset(m_staging_buffer->GetMap(), processed_color.a, m_staging_buffer->GetSize());
-			else
-			{
-				for(std::size_t y = 0; y < m_height; y++)
-				{
-					for(std::size_t x = 0; x < m_width; x++)
-						m_staging_buffer->GetMap<mlx_color*>()[y * m_width + x] = processed_color;
-				}
-			}
+			for(std::size_t i = 0; i < m_width * m_height; i++)
+				m_staging_buffer->GetMap<mlx_color*>()[i] = processed_color;
 		}
 	}
 
@@ -346,6 +381,17 @@ namespace mlx
 		m_has_been_modified = false;
 	}
 
+	mlx_color* Texture::GetBufferCopy() noexcept
+	{
+		MLX_PROFILE_FUNCTION();
+		if(!m_staging_buffer.has_value())
+			OpenCPUBuffer();
+
+		mlx_color* dst = new mlx_color[m_width * m_height];
+		std::memcpy(dst, m_staging_buffer->GetMap<mlx_color*>(), m_width * m_height * sizeof(mlx_color));
+		return dst;
+	}
+
 	void Texture::OpenCPUBuffer()
 	{
 		MLX_PROFILE_FUNCTION();
@@ -362,8 +408,16 @@ namespace mlx
 			m_staging_buffer->Init(BufferType::Staging, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, {}, {});
 		#endif
 
+		SyncCPUBuffer();
+	}
+
+	void Texture::SyncCPUBuffer(VkCommandBuffer cmd)
+	{
+		if(!m_staging_buffer.has_value())
+			return;
 		VkImageLayout old_layout = m_layout;
-		VkCommandBuffer cmd = kvfCreateCommandBuffer(RenderCore::Get().GetDevice());
+		if(cmd == VK_NULL_HANDLE)
+			cmd = kvfCreateCommandBuffer(RenderCore::Get().GetDevice());
 		kvfBeginCommandBuffer(cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
 		TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, cmd);
 		kvfCopyImageToBuffer(cmd, m_staging_buffer->Get(), m_image, m_staging_buffer->GetOffset(), VK_IMAGE_ASPECT_COLOR_BIT, { m_width, m_height, 1 });
@@ -375,6 +429,105 @@ namespace mlx
 		kvfDestroyCommandBuffer(RenderCore::Get().GetDevice(), cmd);
 	}
 
+	void Texture::CopyTo(Texture& other)
+	{
+		VkImageLayout old_layout = m_layout;
+		VkImageLayout other_old_layout = other.GetLayout();
+
+		VkImageSubresourceLayers subresource{};
+		subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		subresource.mipLevel = 0;
+		subresource.layerCount = 1;
+		subresource.baseArrayLayer = 0;
+
+		VkExtent3D extent{};
+		extent.width = m_width;
+		extent.height = m_height;
+		extent.depth = 1;
+
+		VkOffset3D offset{};
+		offset.x = 0;
+		offset.y = 0;
+		offset.z = 0;
+
+		VkImageCopy region{};
+		region.srcSubresource = subresource;
+		region.dstSubresource = subresource;
+		region.extent = extent;
+		region.srcOffset = offset;
+		region.dstOffset = offset;
+
+		VkCommandBuffer cmd = kvfCreateCommandBuffer(RenderCore::Get().GetDevice());
+		kvfBeginCommandBuffer(cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
+
+		TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, cmd);
+		other.TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
+
+		kvfCopyImageToImage(cmd, m_image, m_layout, other.Get(), other.GetLayout(), 1, &region);
+
+		TransitionLayout(old_layout, cmd);
+		other.TransitionLayout(other_old_layout, cmd);
+
+		kvfEndCommandBuffer(cmd);
+
+		SyncCPUBuffer(cmd);
+	}
+
+	void Texture::Resize(std::uint32_t width, std::uint32_t height)
+	{
+		#ifdef DEBUG
+			Texture new_texture = Texture(CPUBuffer{}, width, height, m_format, m_is_multisampled, m_debug_name);
+		#else
+			Texture new_texture = Texture(CPUBuffer{}, width, height, m_format, m_is_multisampled, std::string_view{});
+		#endif
+
+		if(m_staging_buffer.has_value())
+		{
+			new_texture.OpenCPUBuffer();
+			new_texture.m_staging_buffer->CopyFrom(*m_staging_buffer);
+		}
+
+		// Suboptimal operations, should bake all of them in a single command buffer
+		new_texture.Clear(VK_NULL_HANDLE, Vec4f{ 0.f });
+		CopyTo(new_texture);
+
+		Swap(new_texture);
+
+		#ifdef DEBUG
+			DebugLog("Texture: resized '%'", m_debug_name);
+		#endif
+	}
+
+	void Texture::Swap(Texture& texture) noexcept
+	{
+		MLX_PROFILE_FUNCTION();
+
+		#ifdef DEBUG
+			std::swap(m_debug_name, texture.m_debug_name);
+		#endif
+		std::swap(m_allocation, texture.m_allocation);
+		std::swap(m_image, texture.m_image);
+		std::swap(m_image_view, texture.m_image_view);
+		std::swap(m_sampler, texture.m_sampler);
+		std::swap(m_format, texture.m_format);
+		std::swap(m_tiling, texture.m_tiling);
+		std::swap(m_layout, texture.m_layout);
+		std::swap(m_type, texture.m_type);
+		std::swap(m_width, texture.m_width);
+		std::swap(m_height, texture.m_height);
+		std::swap(m_is_multisampled, texture.m_is_multisampled);
+
+		if(m_staging_buffer.has_value() && texture.m_staging_buffer.has_value())
+			m_staging_buffer->Swap(*texture.m_staging_buffer);
+		else if(m_staging_buffer.has_value())
+			m_staging_buffer.reset();
+		else if(texture.m_staging_buffer.has_value())
+			texture.m_staging_buffer.reset();
+
+		m_has_been_modified = true;
+		texture.m_has_been_modified = true;
+	}
+
 	Texture* StbTextureLoad(const std::filesystem::path& file, int* w, int* h)
 	{
 		using namespace std::literals;

runtime/Sources/Renderer/Pipelines/Graphics.cpp

@@ -127,6 +127,9 @@ namespace mlx
 	void GraphicPipeline::Destroy() noexcept
 	{
 		MLX_PROFILE_FUNCTION();
+		if(m_pipeline == VK_NULL_HANDLE)
+			return;
+
 		p_vertex_shader.reset();
 		p_fragment_shader.reset();
 		for(auto fb : m_framebuffers)

runtime/Sources/Renderer/RenderCore.cpp

@@ -100,8 +100,25 @@ namespace mlx
 			info.width = 1;
 			info.height = 1;
 			window = std::make_unique<Window>(&info, true);
-			instance_extensions = window->GetRequiredVulkanInstanceExtentions();
-			#ifdef MLX_PLAT_MACOS
+			instance_extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
+			#ifdef VK_USE_PLATFORM_XCB_KHR
+				instance_extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
+			#endif
+
+			#ifdef VK_USE_PLATFORM_XLIB_KHR
+				instance_extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+			#endif
+
+			#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+				 instance_extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
+			#endif
+
+			#ifdef VK_USE_PLATFORM_WIN32_KHR
+				instance_extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
+			#endif
+
+			#ifdef VK_USE_PLATFORM_METAL_EXT
+				instance_extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
 				instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
 			#endif
 		}
@@ -185,6 +202,41 @@ namespace mlx
 		MLX_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR);
 		MLX_LOAD_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR);
 		MLX_LOAD_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR);
+		#ifdef VK_USE_PLATFORM_ANDROID_KHR
+			#ifdef VK_KHR_android_surface
+				MLX_LOAD_FUNCTION(vkCreateAndroidSurfaceKHR);
+			#endif
+		#endif
+
+		#ifdef VK_USE_PLATFORM_XCB_KHR
+			#ifdef VK_KHR_xcb_surface
+				MLX_LOAD_FUNCTION(vkCreateXcbSurfaceKHR);
+			#endif
+		#endif
+
+		#ifdef VK_USE_PLATFORM_XLIB_KHR
+			#ifdef VK_KHR_xlib_surface
+				MLX_LOAD_FUNCTION(vkCreateXlibSurfaceKHR);
+			#endif
+		#endif
+
+		#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+			#ifdef VK_KHR_wayland_surface
+				MLX_LOAD_FUNCTION(vkCreateWaylandSurfaceKHR);
+			#endif
+		#endif
+
+		#ifdef VK_USE_PLATFORM_WIN32_KHR
+			#ifdef VK_KHR_win32_surface
+				MLX_LOAD_FUNCTION(vkCreateWin32SurfaceKHR);
+			#endif
+		#endif
+
+		#ifdef VK_USE_PLATFORM_METAL_EXT
+			#ifdef VK_EXT_metal_surface
+				MLX_LOAD_FUNCTION(vkCreateMetalSurfaceEXT);
+			#endif
+		#endif
 		kvfPassInstanceVulkanFunctionPointers(&pfns);
 	}
 

runtime/Sources/Renderer/Swapchain.cpp

@@ -161,7 +161,7 @@ namespace mlx
 
 		std::function<void(const EventBase&)> functor = [this](const EventBase& event)
 		{
-			if(event.What() == Event::ResizeEventCode && !m_resize)
+			if(event.What() == Event::SwapchainResizeEventCode && !m_resize)
 				m_resize = true;
 		};
 		EventBus::RegisterListener({ functor, "mlx_swapchain_" + std::to_string(reinterpret_cast<std::uintptr_t>(this)) });

third_party/kvf.h

@@ -55,6 +55,46 @@
 	#define VK_NO_PROTOTYPES
 #endif
 
+#ifndef KVF_NO_KHR
+	#ifdef VK_USE_PLATFORM_ANDROID_KHR
+		#include <vulkan/vulkan_android.h>
+	#endif
+
+	#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+		#include <vulkan/vulkan_wayland.h>
+	#endif
+
+	#ifdef VK_USE_PLATFORM_WIN32_KHR
+		typedef struct HINSTANCE__* HINSTANCE;
+		typedef struct HWND__* HWND;
+		typedef struct HMONITOR__* HMONITOR;
+		typedef void* HANDLE;
+		typedef /*_Null_terminated_*/ const wchar_t* LPCWSTR;
+		typedef unsigned long DWORD;
+		typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES;
+		#include <vulkan/vulkan_win32.h>
+	#endif
+
+	#ifdef VK_USE_PLATFORM_XCB_KHR
+		struct xcb_connection_t;
+		typedef uint32_t xcb_window_t;
+		typedef uint32_t xcb_visualid_t;
+		#include <vulkan/vulkan_xcb.h>
+	#endif
+
+	#ifdef VK_USE_PLATFORM_METAL_EXT
+		#include <vulkan/vulkan_metal.h>
+	#endif
+
+	#ifdef VK_USE_PLATFORM_XLIB_KHR
+		typedef struct _XDisplay Display;
+		typedef unsigned long XID;
+		typedef XID Window;
+		typedef unsigned long VisualID;
+		#include <vulkan/vulkan_xlib.h>
+	#endif
+#endif
+
 #include <vulkan/vulkan_core.h>
 
 #include <stdint.h>
@@ -82,6 +122,18 @@ typedef enum
 	KVF_IMAGE_OTHER = 4,
 } KvfImageType;
 
+#ifndef KVF_NO_KHR
+	typedef enum
+	{
+		KVF_SURFACE_ANDROID = 0,
+		KVF_SURFACE_XLIB = 1,
+		KVF_SURFACE_XCB = 2,
+		KVF_SURFACE_WAYLAND = 3,
+		KVF_SURFACE_WINDOWS = 4,
+		KVF_SURFACE_METAL = 5,
+	} KvfSurfaceType;
+#endif
+
 typedef void (*KvfErrorCallback)(const char* message);
 
 #ifdef KVF_IMPL_VK_NO_PROTOTYPES
@@ -148,10 +200,39 @@ void kvfDestroySemaphore(VkDevice device, VkSemaphore semaphore);
 	uint32_t kvfGetSwapchainMinImagesCount(VkSwapchainKHR swapchain);
 	VkExtent2D kvfGetSwapchainImagesSize(VkSwapchainKHR swapchain);
 	void kvfDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain);
+
+	/**
+	 * For Windows:
+	 *  - instance_handle -> HINSTANCE
+	 *  - window_handle   -> HWND window handle
+	 *
+	 * For Wayland:
+	 *  - instance_handle -> wl_display
+	 *  - window_handle   -> wl_surface
+	 *
+	 * For XLIB:
+	 *  - instance_handle -> Display
+	 *  - window_handle   -> Window
+	 *
+	 * For XCB:
+	 *  - instance_handle -> xcb_connection_t
+	 *  - window_handle   -> xcb_window_t
+	 *
+	 * For Metal:
+	 *  - instance_handle -> ignored
+	 *  - window_handle   -> CAMetalLayer
+	 *
+	 * For Android:
+	 *  - instance_handle -> ignored
+	 *  - window_handle   -> ANativeWindow
+	 */
+	VkSurfaceKHR kvfCreateSurfaceKHR(VkInstance instance, KvfSurfaceType type, void* instance_handle, void* window_handle);
 #endif
 
 VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type);
 void kvfCopyImageToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkImage src, size_t buffer_offset, VkImageAspectFlagBits aspect, VkExtent3D extent);
+void kvfCopyImageToImage(VkCommandBuffer cmd, VkImage src, VkImageLayout src_layout, VkImage dst, VkImageLayout dst_layout, uint32_t count, const VkImageCopy* regions);
+
 void kvfDestroyImage(VkDevice device, VkImage image);
 VkImageView kvfCreateImageView(VkDevice device, VkImage image, VkFormat format, VkImageViewType type, VkImageAspectFlags aspect, int layer_count);
 void kvfDestroyImageView(VkDevice device, VkImageView image_view);
@@ -270,6 +351,42 @@ int32_t kvfFindMemoryType(VkPhysicalDevice physical_device, uint32_t type_filter
 			KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkGetPhysicalDeviceSurfaceFormatsKHR);
 			KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkGetPhysicalDeviceSurfacePresentModesKHR);
 			KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkGetPhysicalDeviceSurfaceSupportKHR);
+
+			#ifdef VK_USE_PLATFORM_ANDROID_KHR
+				#ifdef VK_KHR_android_surface
+					KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkCreateAndroidSurfaceKHR);
+				#endif
+			#endif
+
+			#ifdef VK_USE_PLATFORM_XCB_KHR
+				#ifdef VK_KHR_xcb_surface
+					KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkCreateXcbSurfaceKHR);
+				#endif
+			#endif
+
+			#ifdef VK_USE_PLATFORM_XLIB_KHR
+				#ifdef VK_KHR_xlib_surface
+					KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkCreateXlibSurfaceKHR);
+				#endif
+			#endif
+
+			#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+				#ifdef VK_KHR_wayland_surface
+					KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkCreateWaylandSurfaceKHR);
+				#endif
+			#endif
+
+			#ifdef VK_USE_PLATFORM_WIN32_KHR
+				#ifdef VK_KHR_win32_surface
+					KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkCreateWin32SurfaceKHR);
+				#endif
+			#endif
+
+			#ifdef VK_USE_PLATFORM_METAL_EXT
+				#ifdef VK_EXT_metal_surface
+					KVF_DEFINE_VULKAN_FUNCTION_PROTOTYPE(vkCreateMetalSurfaceEXT);
+				#endif
+			#endif
 		#endif
 	};
 
@@ -2091,6 +2208,98 @@ void kvfDestroySemaphore(VkDevice device, VkSemaphore semaphore)
 		KVF_ASSERT(device != VK_NULL_HANDLE);
 		__kvfDestroySwapchain(device, swapchain);
 	}
+
+	VkSurfaceKHR kvfCreateSurfaceKHR(VkInstance instance, KvfSurfaceType type, void* instance_handle, void* window_handle)
+	{
+		VkSurfaceKHR surface = VK_NULL_HANDLE;
+		switch(type)
+		{
+			#ifdef VK_USE_PLATFORM_ANDROID_KHR
+				case KVF_SURFACE_ANDROID:
+				{
+					VkAndroidSurfaceCreateInfoKHR create_info = {};
+					create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+					create_info.pNext = nullptr;
+					create_info.flags = 0;
+					create_info.window = (ANativeWindow*)window_handle;
+					kvfCheckVk(KVF_GET_INSTANCE_FUNCTION(vkCreateAndroidSurfaceKHR)(instance, &create_info, NULL, &surface));
+					break;
+				}
+			#endif
+
+			#ifdef VK_USE_PLATFORM_XLIB_KHR
+				case KVF_SURFACE_XLIB:
+				{
+					VkXlibSurfaceCreateInfoKHR create_info = {};
+					create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+					create_info.pNext = nullptr;
+					create_info.flags = 0;
+					create_info.dpy = (Display*)instance_handle;
+					create_info.window = *(Window*)window_handle;
+					kvfCheckVk(KVF_GET_INSTANCE_FUNCTION(vkCreateXlibSurfaceKHR)(instance, &create_info, NULL, &surface));
+					break;
+				}
+			#endif
+
+			#ifdef VK_USE_PLATFORM_XCB_KHR
+				case KVF_SURFACE_XCB:
+				{
+					VkXcbSurfaceCreateInfoKHR create_info = {};
+					create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+					create_info.pNext = nullptr;
+					create_info.flags = 0;
+					create_info.connection = (xcb_connection_t*)instance_handle;
+					create_info.window = (*xcb_window_t*)window_handle;
+					kvfCheckVk(KVF_GET_INSTANCE_FUNCTION(vkCreateXcbSurfaceKHR)(instance, &create_info, NULL, &surface));
+					break;
+				}
+			#endif
+
+			#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+				case KVF_SURFACE_WAYLAND:
+				{
+					VkWaylandSurfaceCreateInfoKHR create_info = {};
+					create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+					create_info.pNext = nullptr;
+					create_info.flags = 0;
+					create_info.display = (wl_display*)instance_handle;
+					create_info.surface = (wl_surface*)window_handle;
+					kvfCheckVk(KVF_GET_INSTANCE_FUNCTION(vkCreateWaylandSurfaceKHR)(instance, &create_info, NULL, &surface));
+					break;
+				}
+			#endif
+
+			#ifdef VK_USE_PLATFORM_WIN32_KHR
+				case KVF_SURFACE_WINDOWS:
+				{
+					VkWin32SurfaceCreateInfoKHR create_info = {};
+					create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+					create_info.pNext = nullptr;
+					create_info.flags = 0;
+					create_info.hinstance = (HINSTANCE)instance_handle;
+					create_info.hwnd = (HWND)window_handle;
+					kvfCheckVk(KVF_GET_INSTANCE_FUNCTION(vkCreateWin32SurfaceKHR)(instance, &create_info, NULL, &surface));
+					break;
+				}
+			#endif
+
+			#ifdef VK_USE_PLATFORM_METAL_EXT
+				case KVF_SURFACE_METAL:
+				{
+					VkMetalSurfaceCreateInfoEXT create_info = {};
+					create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+					create_info.pNext = nullptr;
+					create_info.flags = 0;
+					create_info.pLayer = (CAMetalLayer*)window_handle;
+					kvfCheckVk(KVF_GET_INSTANCE_FUNCTION(vkCreateMetalSurfaceEXT)(instance, &create_info, NULL, &surface));
+					break;
+				}
+			#endif
+
+			default: break;
+		}
+		return surface;
+	}
 #endif
 
 VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type)
@@ -2147,6 +2356,18 @@ void kvfCopyImageToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkImage src, size_t
 	KVF_GET_DEVICE_FUNCTION(vkCmdCopyImageToBuffer)(cmd, src, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst, 1, &region);
 }
 
+void kvfCopyImageToImage(VkCommandBuffer cmd, VkImage src, VkImageLayout src_layout, VkImage dst, VkImageLayout dst_layout, uint32_t count, const VkImageCopy* regions)
+{
+	KVF_ASSERT(cmd != VK_NULL_HANDLE);
+	KVF_ASSERT(dst != VK_NULL_HANDLE);
+	KVF_ASSERT(src != VK_NULL_HANDLE);
+	#ifdef KVF_IMPL_VK_NO_PROTOTYPES
+		__KvfDevice* kvf_device = __kvfGetKvfDeviceFromVkCommandBuffer(cmd);
+		KVF_ASSERT(kvf_device != NULL && "could not find VkDevice in registered devices");
+	#endif
+	KVF_GET_DEVICE_FUNCTION(vkCmdCopyImage)(cmd, src, src_layout, dst, dst_layout, count, regions);
+}
+
 void kvfDestroyImage(VkDevice device, VkImage image)
 {
 	if(image == VK_NULL_HANDLE)
@@ -2955,7 +3176,7 @@ void kvfGPipelineBuilderEnableAdditiveBlending(KvfGraphicsPipelineBuilder* build
 	builder->color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
 	builder->color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD;
 	builder->color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
-	builder->color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+	builder->color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 	builder->color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD;
 }
 
@@ -2968,7 +3189,7 @@ void kvfGPipelineBuilderEnableAlphaBlending(KvfGraphicsPipelineBuilder* builder)
 	builder->color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 	builder->color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD;
 	builder->color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
-	builder->color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+	builder->color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
 	builder->color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD;
 }
 

third_party/vk_video/vulkan_video_codec_av1std.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_av1std_decode.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_av1std_encode.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_h264std.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*
@@ -44,6 +44,8 @@ typedef enum StdVideoH264ProfileIdc {
     STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66,
     STD_VIDEO_H264_PROFILE_IDC_MAIN = 77,
     STD_VIDEO_H264_PROFILE_IDC_HIGH = 100,
+    STD_VIDEO_H264_PROFILE_IDC_HIGH_10 = 110,
+    STD_VIDEO_H264_PROFILE_IDC_HIGH_422 = 122,
     STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244,
     STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF,
     STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF

third_party/vk_video/vulkan_video_codec_h264std_decode.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_h264std_encode.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_h265std.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_h265std_decode.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_h265std_encode.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_vp9std.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codec_vp9std_decode.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vk_video/vulkan_video_codecs_common.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vk_icd.h

@@ -2,8 +2,7 @@
  * Copyright 2015-2023 The Khronos Group Inc.
  * Copyright 2015-2023 Valve Corporation
  * Copyright 2015-2023 LunarG, Inc.
- *
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
  */
 #pragma once
 

third_party/vulkan/vk_layer.h

@@ -2,8 +2,7 @@
  * Copyright 2015-2023 The Khronos Group Inc.
  * Copyright 2015-2023 Valve Corporation
  * Copyright 2015-2023 LunarG, Inc.
- *
- * SPDX-License-Identifier: Apache-2.0
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
  */
 #pragma once
 

third_party/vulkan/vk_platform.h

@@ -3,8 +3,7 @@
 //
 /*
 ** Copyright 2014-2026 The Khronos Group Inc.
-**
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 

third_party/vulkan/vulkan.h

@@ -3,8 +3,7 @@
 
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
-**
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 #include "vk_platform.h"

third_party/vulkan/vulkan_android.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_beta.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_directfb.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_extension_inspection.hpp

@@ -1,5 +1,4 @@
 // Copyright 2015-2026 The Khronos Group Inc.
-//
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
 
@@ -16,7 +15,13 @@
 #  include <vulkan/vulkan.hpp>
 #endif
 
-namespace VULKAN_HPP_NAMESPACE
+#if defined( VULKAN_HPP_CXX_MODULE )
+#  define VULKAN_HPP_EXPORT export
+#else
+#  define VULKAN_HPP_EXPORT
+#endif
+
+VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 {
   //======================================
   //=== Extension inspection functions ===
@@ -44,7 +49,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::map<std::string, std::string> const & getDeprecatedExtensions()
   {
-    static const std::map<std::string, std::string> deprecatedExtensions = { { "VK_EXT_debug_report", "VK_EXT_debug_utils" },
+    static std::map<std::string, std::string> const deprecatedExtensions = { { "VK_EXT_debug_report", "VK_EXT_debug_utils" },
                                                                              { "VK_NV_glsl_shader", "" },
                                                                              { "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" },
                                                                              { "VK_AMD_gpu_shader_half_float", "VK_KHR_shader_float16_int8" },
@@ -67,16 +72,18 @@ namespace VULKAN_HPP_NAMESPACE
                                                                              { "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" },
                                                                              { "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" },
                                                                              { "VK_EXT_validation_features", "VK_EXT_layer_settings" },
+                                                                             { "VK_NV_low_latency", "VK_NV_low_latency2" },
+                                                                             { "VK_EXT_descriptor_buffer", "VK_EXT_descriptor_heap" },
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
-                                                                             { "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" }
+                                                                             { "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" },
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    };
+                                                                             { "VK_NV_per_stage_descriptor_set", "VK_EXT_descriptor_heap" } };
     return deprecatedExtensions;
   }
 
   VULKAN_HPP_INLINE std::set<std::string> const & getDeviceExtensions()
   {
-    static const std::set<std::string> deviceExtensions = { "VK_KHR_swapchain",
+    static std::set<std::string> const deviceExtensions = { "VK_KHR_swapchain",
                                                             "VK_KHR_display_swapchain",
                                                             "VK_NV_glsl_shader",
                                                             "VK_EXT_depth_range_unrestricted",
@@ -172,9 +179,11 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_EXT_sampler_filter_minmax",
                                                             "VK_KHR_storage_buffer_storage_class",
                                                             "VK_AMD_gpu_shader_int16",
+                                                            "VK_AMD_gpa_interface",
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
                                                             "VK_AMDX_shader_enqueue",
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+                                                            "VK_EXT_descriptor_heap",
                                                             "VK_AMD_mixed_attachment_samples",
                                                             "VK_AMD_shader_fragment_mask",
                                                             "VK_EXT_inline_uniform_block",
@@ -209,6 +218,8 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_KHR_draw_indirect_count",
                                                             "VK_EXT_filter_cubic",
                                                             "VK_QCOM_render_pass_shader_resolve",
+                                                            "VK_QCOM_cooperative_matrix_conversion",
+                                                            "VK_QCOM_elapsed_timer_query",
                                                             "VK_EXT_global_priority",
                                                             "VK_KHR_shader_subgroup_extended_types",
                                                             "VK_KHR_8bit_storage",
@@ -254,7 +265,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_KHR_fragment_shading_rate",
                                                             "VK_AMD_shader_core_properties2",
                                                             "VK_AMD_device_coherent_memory",
+                                                            "VK_KHR_shader_constant_data",
                                                             "VK_KHR_dynamic_rendering_local_read",
+                                                            "VK_KHR_shader_abort",
                                                             "VK_EXT_shader_image_atomic_int64",
                                                             "VK_KHR_shader_quad_control",
                                                             "VK_KHR_spirv_1_4",
@@ -309,6 +322,10 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_KHR_video_encode_queue",
                                                             "VK_NV_device_diagnostics_config",
                                                             "VK_QCOM_render_pass_store_ops",
+                                                            "VK_QCOM_queue_perf_hint",
+                                                            "VK_QCOM_image_processing3",
+                                                            "VK_QCOM_shader_multiple_wait_queues",
+                                                            "VK_EXT_shader_split_barrier",
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
                                                             "VK_NV_cuda_kernel_launch",
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -319,6 +336,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
                                                             "VK_KHR_synchronization2",
                                                             "VK_EXT_descriptor_buffer",
+                                                            "VK_KHR_device_address_commands",
                                                             "VK_EXT_graphics_pipeline_library",
                                                             "VK_AMD_shader_early_and_late_fragment_tests",
                                                             "VK_KHR_fragment_shader_barycentric",
@@ -436,9 +454,11 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_ARM_shader_core_builtins",
                                                             "VK_EXT_pipeline_library_group_handles",
                                                             "VK_EXT_dynamic_rendering_unused_attachments",
+                                                            "VK_KHR_internally_synchronized_queues",
                                                             "VK_NV_low_latency2",
                                                             "VK_KHR_cooperative_matrix",
                                                             "VK_ARM_data_graph",
+                                                            "VK_ARM_data_graph_instruction_set_tosa",
                                                             "VK_QCOM_multiview_per_view_render_areas",
                                                             "VK_KHR_compute_shader_derivatives",
                                                             "VK_KHR_video_decode_av1",
@@ -477,14 +497,17 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_KHR_maintenance7",
                                                             "VK_NV_shader_atomic_float16_vector",
                                                             "VK_EXT_shader_replicated_composites",
+                                                            "VK_ARM_tensor_controls",
                                                             "VK_EXT_shader_float8",
                                                             "VK_NV_ray_tracing_validation",
                                                             "VK_NV_cluster_acceleration_structure",
                                                             "VK_NV_partitioned_acceleration_structure",
                                                             "VK_EXT_device_generated_commands",
+                                                            "VK_KHR_device_fault",
                                                             "VK_KHR_maintenance8",
                                                             "VK_MESA_image_alignment_control",
                                                             "VK_KHR_shader_fma",
+                                                            "VK_NV_push_constant_bank",
                                                             "VK_EXT_ray_tracing_invocation_reorder",
                                                             "VK_EXT_depth_clamp_control",
                                                             "VK_KHR_maintenance9",
@@ -492,35 +515,51 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_HUAWEI_hdr_vivid",
                                                             "VK_NV_cooperative_matrix2",
                                                             "VK_ARM_pipeline_opacity_micromap",
+                                                            "VK_KHR_video_encode_feedback2",
+                                                            "VK_IMG_filter_linear_2d",
 #if defined( VK_USE_PLATFORM_METAL_EXT )
                                                             "VK_EXT_external_memory_metal",
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
                                                             "VK_KHR_depth_clamp_zero_one",
                                                             "VK_ARM_performance_counters_by_region",
+                                                            "VK_ARM_shader_instrumentation",
                                                             "VK_EXT_vertex_attribute_robustness",
                                                             "VK_ARM_format_pack",
                                                             "VK_VALVE_fragment_density_map_layered",
                                                             "VK_KHR_robustness2",
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
                                                             "VK_NV_present_metering",
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+                                                            "VK_EXT_multisampled_render_to_swapchain",
                                                             "VK_EXT_fragment_density_map_offset",
                                                             "VK_EXT_zero_initialize_device_memory",
                                                             "VK_KHR_present_mode_fifo_latest_ready",
+                                                            "VK_KHR_opacity_micromap",
                                                             "VK_EXT_shader_64bit_indexing",
                                                             "VK_EXT_custom_resolve",
                                                             "VK_QCOM_data_graph_model",
                                                             "VK_KHR_maintenance10",
+                                                            "VK_ARM_data_graph_optical_flow",
                                                             "VK_EXT_shader_long_vector",
                                                             "VK_SEC_pipeline_cache_incremental_mode",
                                                             "VK_EXT_shader_uniform_buffer_unsized_array",
-                                                            "VK_NV_compute_occupancy_priority" };
+                                                            "VK_NV_compute_occupancy_priority",
+                                                            "VK_KHR_maintenance11",
+                                                            "VK_EXT_cooperative_matrix_maintenance1",
+                                                            "VK_EXT_shader_subgroup_partitioned",
+                                                            "VK_KHR_extended_flags",
+                                                            "VK_EXT_shader_ocp_microscaling_types",
+                                                            "VK_VALVE_shader_mixed_float_dot_product",
+                                                            "VK_SEC_throttle_hint",
+                                                            "VK_ARM_data_graph_neural_accelerator_statistics",
+                                                            "VK_EXT_primitive_restart_index",
+                                                            "VK_EXT_image_tiling_control",
+                                                            "VK_NV_cooperative_matrix_decode_vector",
+                                                            "VK_NV_private_data_base_handle" };
     return deviceExtensions;
   }
 
   VULKAN_HPP_INLINE std::set<std::string> const & getInstanceExtensions()
   {
-    static const std::set<std::string> instanceExtensions = { "VK_KHR_surface",
+    static std::set<std::string> const instanceExtensions = { "VK_KHR_surface",
                                                               "VK_KHR_display",
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
                                                               "VK_KHR_xlib_surface",
@@ -590,16 +629,19 @@ namespace VULKAN_HPP_NAMESPACE
                                                               "VK_EXT_layer_settings",
                                                               "VK_NV_display_stereo",
 #if defined( VK_USE_PLATFORM_OHOS )
-                                                              "VK_OHOS_surface"
+                                                              "VK_OHOS_surface",
 #endif /*VK_USE_PLATFORM_OHOS*/
+#if defined( VK_USE_PLATFORM_UBM_SEC )
+                                                              "VK_SEC_ubm_surface"
+#endif /*VK_USE_PLATFORM_UBM_SEC*/
     };
     return instanceExtensions;
   }
 
   VULKAN_HPP_INLINE std::map<std::string, std::vector<std::vector<std::string>>> const & getExtensionDepends( std::string const & extension )
   {
-    static const std::map<std::string, std::vector<std::vector<std::string>>>                        noDependencies;
-    static const std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
+    static std::map<std::string, std::vector<std::vector<std::string>>> const                        noDependencies;
+    static std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> const dependencies = {
       { "VK_KHR_swapchain",
         { { "VK_VERSION_1_0",
             { {
@@ -1082,6 +1124,12 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
       ,
       { "VK_EXT_sampler_filter_minmax",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_AMD_gpa_interface",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
@@ -1105,6 +1153,24 @@ namespace VULKAN_HPP_NAMESPACE
             } } } } }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
       ,
+      { "VK_EXT_descriptor_heap",
+        { { "VK_VERSION_1_0",
+            { {
+                "VK_KHR_buffer_device_address",
+                "VK_KHR_extended_flags",
+              },
+              {
+                "VK_KHR_buffer_device_address",
+                "VK_KHR_maintenance5",
+              } } },
+          { "VK_VERSION_1_2",
+            { {
+                "VK_KHR_extended_flags",
+              },
+              {
+                "VK_KHR_maintenance5",
+              } } },
+          { "VK_VERSION_1_4", { {} } } } },
       { "VK_EXT_inline_uniform_block",
         { { "VK_VERSION_1_0",
             { {
@@ -1226,6 +1292,17 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_QCOM_cooperative_matrix_conversion",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_cooperative_matrix",
+            } } } } },
+      { "VK_QCOM_elapsed_timer_query",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_shader_subgroup_extended_types", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_8bit_storage",
         { { "VK_VERSION_1_0",
@@ -1465,12 +1542,24 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_constant_data",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_dynamic_rendering_local_read",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_dynamic_rendering",
             } } },
           { "VK_VERSION_1_3", { {} } } } },
+      { "VK_KHR_shader_abort",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_device_fault",
+              "VK_KHR_shader_constant_data",
+            } } } } },
       { "VK_EXT_shader_image_atomic_int64",
         { { "VK_VERSION_1_0",
             { {
@@ -1772,7 +1861,10 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
               "VK_KHR_swapchain",
             } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_KHR_swapchain",
+            } } } } },
       { "VK_EXT_private_data",
         { { "VK_VERSION_1_0",
             { {
@@ -1796,6 +1888,30 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_video_queue",
             } } } } },
       { "VK_NV_device_diagnostics_config",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_QCOM_queue_perf_hint",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_QCOM_image_processing3",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_QCOM_shader_multiple_wait_queues",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_split_barrier",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
@@ -1815,9 +1931,6 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_QCOM_tile_properties",
-              },
-              {
-                "VK_KHR_get_physical_device_properties2",
             } } } } },
       { "VK_KHR_synchronization2",
         { { "VK_VERSION_1_0",
@@ -1844,6 +1957,26 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_synchronization2",
             } } },
           { "VK_VERSION_1_3", { {} } } } },
+      { "VK_KHR_device_address_commands",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_EXT_extended_dynamic_state",
+              "VK_KHR_buffer_device_address",
+              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_synchronization2",
+            } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_EXT_extended_dynamic_state",
+              "VK_KHR_buffer_device_address",
+              "VK_KHR_synchronization2",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
+              "VK_EXT_extended_dynamic_state",
+              "VK_KHR_synchronization2",
+            } } },
+          { "VK_VERSION_1_3", { {} } } } },
       { "VK_EXT_graphics_pipeline_library",
         { { "VK_VERSION_1_0",
             { {
@@ -2318,6 +2451,7 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_EXT_image_compression_control",
+              "VK_KHR_swapchain",
             } } } } },
       { "VK_QCOM_image_processing",
         { { "VK_VERSION_1_0",
@@ -2434,6 +2568,10 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_AMDX_dense_geometry_format",
         { { "VK_VERSION_1_0",
             { {
+                "VK_KHR_acceleration_structure",
+                "VK_KHR_extended_flags",
+              },
+              {
                 "VK_KHR_acceleration_structure",
                 "VK_KHR_maintenance5",
               } } },
@@ -2477,6 +2615,9 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_KHR_pipeline_binary",
         { { "VK_VERSION_1_0",
             { {
+                "VK_KHR_extended_flags",
+              },
+              {
                 "VK_KHR_maintenance5",
               } } },
           { "VK_VERSION_1_4", { {} } } } },
@@ -2495,21 +2636,20 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_KHR_surface_maintenance1",
         { { "VK_VERSION_1_0",
             { {
-                "VK_KHR_surface",
-              },
-              {
               "VK_KHR_get_surface_capabilities2",
+              "VK_KHR_surface",
             } } } } },
       { "VK_KHR_swapchain_maintenance1",
         { { "VK_VERSION_1_0",
             { {
-                "VK_KHR_swapchain",
-              },
-              {
-                "VK_KHR_surface_maintenance1",
-              },
-              {
               "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_surface_maintenance1",
+              "VK_KHR_swapchain",
+            } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_KHR_surface_maintenance1",
+              "VK_KHR_swapchain",
             } } } } },
       { "VK_QCOM_multiview_per_view_viewports",
         { { "VK_VERSION_1_0",
@@ -2568,6 +2708,7 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_dynamic_rendering",
             } } },
           { "VK_VERSION_1_3", { {} } } } },
+      { "VK_KHR_internally_synchronized_queues", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_low_latency2",
         { { "VK_VERSION_1_0",
             { {
@@ -2594,9 +2735,18 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_ARM_data_graph",
         { { "VK_VERSION_1_3",
             { {
+                "VK_KHR_deferred_host_operations",
+                "VK_KHR_extended_flags",
+              },
+              {
                 "VK_KHR_deferred_host_operations",
                 "VK_KHR_maintenance5",
               } } } } },
+      { "VK_ARM_data_graph_instruction_set_tosa",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_ARM_data_graph",
+            } } } } },
       { "VK_QCOM_multiview_per_view_render_areas",
         { { "VK_VERSION_1_0",
             { {
@@ -2808,6 +2958,11 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_ARM_tensor_controls",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_ARM_tensors",
+            } } } } },
       { "VK_EXT_shader_float8",
         { { "VK_VERSION_1_0",
             { {
@@ -2833,14 +2988,27 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_EXT_device_generated_commands",
         { { "VK_VERSION_1_0",
             { {
+                "VK_KHR_buffer_device_address",
+                "VK_KHR_extended_flags",
+              },
+              {
                 "VK_KHR_buffer_device_address",
                 "VK_KHR_maintenance5",
               } } },
           { "VK_VERSION_1_2",
             { {
+                "VK_KHR_extended_flags",
+              },
+              {
                 "VK_KHR_maintenance5",
               } } },
           { "VK_VERSION_1_3", { {} } } } },
+      { "VK_KHR_device_fault",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_MESA_image_alignment_control",
         { { "VK_VERSION_1_0",
@@ -2906,7 +3074,18 @@ namespace VULKAN_HPP_NAMESPACE
         { { "VK_VERSION_1_0",
             { {
               "VK_EXT_opacity_micromap",
-            } } } } }
+            } } } } },
+      { "VK_KHR_video_encode_feedback2",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_encode_queue",
+            } } } } },
+      { "VK_IMG_filter_linear_2d",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_format_feature_flags2",
+            } } },
+          { "VK_VERSION_1_3", { {} } } } }
 #if defined( VK_USE_PLATFORM_METAL_EXT )
       ,
       { "VK_EXT_external_memory_metal",
@@ -2929,6 +3108,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_ARM_shader_instrumentation",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_vertex_attribute_robustness",
         { { "VK_VERSION_1_0",
             { {
@@ -2944,6 +3129,10 @@ namespace VULKAN_HPP_NAMESPACE
       { "VK_VALVE_fragment_density_map_layered",
         { { "VK_VERSION_1_0",
             { {
+                "VK_EXT_fragment_density_map",
+                "VK_KHR_extended_flags",
+              },
+              {
                 "VK_EXT_fragment_density_map",
                 "VK_KHR_maintenance5",
               } } },
@@ -2956,17 +3145,19 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
-          { "VK_VERSION_1_1", { {} } } } }
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-      ,
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_present_metering",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
-          { "VK_VERSION_1_1", { {} } } } }
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-      ,
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_multisampled_render_to_swapchain",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_EXT_multisampled_render_to_single_sampled",
+              "VK_KHR_swapchain",
+            } } } } },
       { "VK_EXT_fragment_density_map_offset",
         { { "VK_VERSION_1_0",
             { {
@@ -3001,6 +3192,12 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_swapchain",
             } } } } },
+      { "VK_KHR_opacity_micromap",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_acceleration_structure",
+              "VK_KHR_device_address_commands",
+            } } } } },
       { "VK_EXT_shader_64bit_indexing",
         { { "VK_VERSION_1_0",
             { {
@@ -3024,6 +3221,11 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_ARM_data_graph_optical_flow",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_ARM_data_graph",
+            } } } } },
       { "VK_EXT_shader_long_vector", { { "VK_VERSION_1_2", { {} } } } },
       { "VK_SEC_pipeline_cache_incremental_mode",
         { { "VK_VERSION_1_0",
@@ -3038,11 +3240,89 @@ namespace VULKAN_HPP_NAMESPACE
             } } },
           { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_compute_occupancy_priority",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_maintenance11",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_cooperative_matrix_maintenance1",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_cooperative_matrix",
+            } } } } },
+      { "VK_EXT_shader_subgroup_partitioned",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } }
+#if defined( VK_USE_PLATFORM_UBM_SEC )
+      ,
+      { "VK_SEC_ubm_surface",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_surface",
+            } } } } }
+#endif /*VK_USE_PLATFORM_UBM_SEC*/
+      ,
+      { "VK_KHR_extended_flags",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_ocp_microscaling_types",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_VALVE_shader_mixed_float_dot_product",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+              "VK_KHR_shader_float16_int8",
+            } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_KHR_shader_float16_int8",
+            } } },
+          { "VK_VERSION_1_2", { {} } } } },
+      { "VK_ARM_data_graph_neural_accelerator_statistics",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_primitive_restart_index",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_image_tiling_control",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_cooperative_matrix_decode_vector",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_NV_cooperative_matrix2",
+            } } } } },
+      { "VK_NV_private_data_base_handle",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_EXT_private_data",
+            } } },
+          { "VK_VERSION_1_3", { {} } } } }
     };
     auto depIt = dependencies.find( extension );
     return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@@ -3079,13 +3359,13 @@ namespace VULKAN_HPP_NAMESPACE
 
   VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions()
   {
-    static const std::map<std::string, std::string> obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } };
+    static std::map<std::string, std::string> const obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } };
     return obsoletedExtensions;
   }
 
   VULKAN_HPP_INLINE std::map<std::string, std::string> const & getPromotedExtensions()
   {
-    static const std::map<std::string, std::string> promotedExtensions = { { "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" },
+    static std::map<std::string, std::string> const promotedExtensions = { { "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" },
                                                                            { "VK_EXT_debug_marker", "VK_EXT_debug_utils" },
                                                                            { "VK_AMD_draw_indirect_count", "VK_KHR_draw_indirect_count" },
                                                                            { "VK_KHR_dynamic_rendering", "VK_VERSION_1_3" },
@@ -3138,6 +3418,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                                            { "VK_EXT_pipeline_creation_feedback", "VK_VERSION_1_3" },
                                                                            { "VK_KHR_driver_properties", "VK_VERSION_1_2" },
                                                                            { "VK_KHR_shader_float_controls", "VK_VERSION_1_2" },
+                                                                           { "VK_NV_shader_subgroup_partitioned", "VK_EXT_shader_subgroup_partitioned" },
                                                                            { "VK_KHR_depth_stencil_resolve", "VK_VERSION_1_2" },
                                                                            { "VK_NV_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives" },
                                                                            { "VK_NV_fragment_shader_barycentric", "VK_KHR_fragment_shader_barycentric" },
@@ -3174,6 +3455,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                                            { "VK_EXT_image_robustness", "VK_VERSION_1_3" },
                                                                            { "VK_KHR_copy_commands2", "VK_VERSION_1_3" },
                                                                            { "VK_EXT_4444_formats", "VK_VERSION_1_3" },
+                                                                           { "VK_EXT_device_fault", "VK_KHR_device_fault" },
                                                                            { "VK_ARM_rasterization_order_attachment_access",
                                                                              "VK_EXT_rasterization_order_attachment_access" },
                                                                            { "VK_VALVE_mutable_descriptor_type", "VK_EXT_mutable_descriptor_type" },
@@ -3181,6 +3463,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                                            { "VK_EXT_present_mode_fifo_latest_ready", "VK_KHR_present_mode_fifo_latest_ready" },
                                                                            { "VK_EXT_extended_dynamic_state2", "VK_VERSION_1_3" },
                                                                            { "VK_EXT_global_priority_query", "VK_KHR_global_priority" },
+                                                                           { "VK_EXT_opacity_micromap", "VK_KHR_opacity_micromap" },
                                                                            { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" },
                                                                            { "VK_KHR_maintenance4", "VK_VERSION_1_3" },
                                                                            { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" },
@@ -3278,13 +3561,24 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_EXT_layer_settings";
     }
+    if ( extension == "VK_NV_low_latency" )
+    {
+      return "VK_NV_low_latency2";
+    }
+    if ( extension == "VK_EXT_descriptor_buffer" )
+    {
+      return "VK_EXT_descriptor_heap";
+    }
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
     if ( extension == "VK_NV_displacement_micromap" )
     {
       return "VK_NV_cluster_acceleration_structure";
     }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
+    if ( extension == "VK_NV_per_stage_descriptor_set" )
+    {
+      return "VK_EXT_descriptor_heap";
+    }
     return "";
   }
 
@@ -3505,6 +3799,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_2";
     }
+    if ( extension == "VK_NV_shader_subgroup_partitioned" )
+    {
+      return "VK_EXT_shader_subgroup_partitioned";
+    }
     if ( extension == "VK_KHR_depth_stencil_resolve" )
     {
       return "VK_VERSION_1_2";
@@ -3649,6 +3947,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_VERSION_1_3";
     }
+    if ( extension == "VK_EXT_device_fault" )
+    {
+      return "VK_KHR_device_fault";
+    }
     if ( extension == "VK_ARM_rasterization_order_attachment_access" )
     {
       return "VK_EXT_rasterization_order_attachment_access";
@@ -3673,6 +3975,10 @@ namespace VULKAN_HPP_NAMESPACE
     {
       return "VK_KHR_global_priority";
     }
+    if ( extension == "VK_EXT_opacity_micromap" )
+    {
+      return "VK_KHR_opacity_micromap";
+    }
     if ( extension == "VK_EXT_load_store_op_none" )
     {
       return "VK_KHR_load_store_op_none";
@@ -3764,11 +4070,11 @@ namespace VULKAN_HPP_NAMESPACE
         || ( extension == "VK_MVK_macos_surface" )
 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
         || ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
-           ( extension == "VK_EXT_validation_features" )
+           ( extension == "VK_EXT_validation_features" ) || ( extension == "VK_NV_low_latency" ) || ( extension == "VK_EXT_descriptor_buffer" )
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
         || ( extension == "VK_NV_displacement_micromap" )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        || false;
+        || ( extension == "VK_NV_per_stage_descriptor_set" );
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension )
@@ -3823,11 +4129,11 @@ namespace VULKAN_HPP_NAMESPACE
         || ( extension == "VK_ANDROID_external_memory_android_hardware_buffer" )
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
         || ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) ||
-           ( extension == "VK_AMD_gpu_shader_int16" )
+           ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_AMD_gpa_interface" )
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
         || ( extension == "VK_AMDX_shader_enqueue" )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        || ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
+        || ( extension == "VK_EXT_descriptor_heap" ) || ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
            ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) ||
            ( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
            ( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) ||
@@ -3842,7 +4148,8 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
         || ( extension == "VK_NV_shading_rate_image" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_NV_representative_fragment_test" ) ||
            ( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) || ( extension == "VK_EXT_filter_cubic" ) ||
-           ( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_EXT_global_priority" ) ||
+           ( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_QCOM_cooperative_matrix_conversion" ) ||
+           ( extension == "VK_QCOM_elapsed_timer_query" ) || ( extension == "VK_EXT_global_priority" ) ||
            ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
            ( extension == "VK_EXT_external_memory_host" ) || ( extension == "VK_AMD_buffer_marker" ) || ( extension == "VK_KHR_shader_atomic_int64" ) ||
            ( extension == "VK_KHR_shader_clock" ) || ( extension == "VK_AMD_pipeline_compiler_control" ) || ( extension == "VK_EXT_calibrated_timestamps" ) ||
@@ -3864,12 +4171,12 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_GOOGLE_hlsl_functionality1" ) || ( extension == "VK_GOOGLE_decorate_string" ) ||
            ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_fragment_shading_rate" ) ||
            ( extension == "VK_AMD_shader_core_properties2" ) || ( extension == "VK_AMD_device_coherent_memory" ) ||
-           ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_EXT_shader_image_atomic_int64" ) ||
-           ( extension == "VK_KHR_shader_quad_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_EXT_memory_budget" ) ||
-           ( extension == "VK_EXT_memory_priority" ) || ( extension == "VK_NV_dedicated_allocation_image_aliasing" ) ||
-           ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
-           ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_present_wait" ) ||
-           ( extension == "VK_NV_cooperative_matrix" ) || ( extension == "VK_NV_coverage_reduction_mode" ) ||
+           ( extension == "VK_KHR_shader_constant_data" ) || ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_KHR_shader_abort" ) ||
+           ( extension == "VK_EXT_shader_image_atomic_int64" ) || ( extension == "VK_KHR_shader_quad_control" ) || ( extension == "VK_KHR_spirv_1_4" ) ||
+           ( extension == "VK_EXT_memory_budget" ) || ( extension == "VK_EXT_memory_priority" ) ||
+           ( extension == "VK_NV_dedicated_allocation_image_aliasing" ) || ( extension == "VK_KHR_separate_depth_stencil_layouts" ) ||
+           ( extension == "VK_EXT_buffer_device_address" ) || ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) ||
+           ( extension == "VK_KHR_present_wait" ) || ( extension == "VK_NV_cooperative_matrix" ) || ( extension == "VK_NV_coverage_reduction_mode" ) ||
            ( extension == "VK_EXT_fragment_shader_interlock" ) || ( extension == "VK_EXT_ycbcr_image_arrays" ) ||
            ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || ( extension == "VK_EXT_provoking_vertex" )
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
@@ -3888,7 +4195,8 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_KHR_pipeline_library" ) || ( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) ||
            ( extension == "VK_KHR_present_id" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) ||
            ( extension == "VK_KHR_video_encode_queue" ) || ( extension == "VK_NV_device_diagnostics_config" ) ||
-           ( extension == "VK_QCOM_render_pass_store_ops" )
+           ( extension == "VK_QCOM_render_pass_store_ops" ) || ( extension == "VK_QCOM_queue_perf_hint" ) || ( extension == "VK_QCOM_image_processing3" ) ||
+           ( extension == "VK_QCOM_shader_multiple_wait_queues" ) || ( extension == "VK_EXT_shader_split_barrier" )
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
         || ( extension == "VK_NV_cuda_kernel_launch" )
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -3896,12 +4204,12 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_METAL_EXT )
         || ( extension == "VK_EXT_metal_objects" )
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
-        || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_descriptor_buffer" ) || ( extension == "VK_EXT_graphics_pipeline_library" ) ||
-           ( extension == "VK_AMD_shader_early_and_late_fragment_tests" ) || ( extension == "VK_KHR_fragment_shader_barycentric" ) ||
-           ( extension == "VK_KHR_shader_subgroup_uniform_control_flow" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) ||
-           ( extension == "VK_NV_fragment_shading_rate_enums" ) || ( extension == "VK_NV_ray_tracing_motion_blur" ) || ( extension == "VK_EXT_mesh_shader" ) ||
-           ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_fragment_density_map2" ) ||
-           ( extension == "VK_QCOM_rotated_copy_commands" ) || ( extension == "VK_EXT_image_robustness" ) ||
+        || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_descriptor_buffer" ) || ( extension == "VK_KHR_device_address_commands" ) ||
+           ( extension == "VK_EXT_graphics_pipeline_library" ) || ( extension == "VK_AMD_shader_early_and_late_fragment_tests" ) ||
+           ( extension == "VK_KHR_fragment_shader_barycentric" ) || ( extension == "VK_KHR_shader_subgroup_uniform_control_flow" ) ||
+           ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_NV_fragment_shading_rate_enums" ) ||
+           ( extension == "VK_NV_ray_tracing_motion_blur" ) || ( extension == "VK_EXT_mesh_shader" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) ||
+           ( extension == "VK_EXT_fragment_density_map2" ) || ( extension == "VK_QCOM_rotated_copy_commands" ) || ( extension == "VK_EXT_image_robustness" ) ||
            ( extension == "VK_KHR_workgroup_memory_explicit_layout" ) || ( extension == "VK_KHR_copy_commands2" ) ||
            ( extension == "VK_EXT_image_compression_control" ) || ( extension == "VK_EXT_attachment_feedback_loop_layout" ) ||
            ( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_device_fault" ) ||
@@ -3959,8 +4267,9 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_NV_cooperative_vector" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
            ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
            ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
-           ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
-           ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
+           ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_KHR_internally_synchronized_queues" ) ||
+           ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) ||
+           ( extension == "VK_ARM_data_graph_instruction_set_tosa" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
            ( extension == "VK_KHR_compute_shader_derivatives" ) || ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) ||
            ( extension == "VK_KHR_video_decode_vp9" ) || ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) ||
            ( extension == "VK_QCOM_image_processing2" ) || ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) ||
@@ -3978,27 +4287,32 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) ||
            ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
            ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
-           ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_EXT_shader_float8" ) ||
+           ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_ARM_tensor_controls" ) || ( extension == "VK_EXT_shader_float8" ) ||
            ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) ||
            ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
-           ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) ||
-           ( extension == "VK_EXT_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
-           ( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
-           ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
+           ( extension == "VK_KHR_device_fault" ) || ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) ||
+           ( extension == "VK_KHR_shader_fma" ) || ( extension == "VK_NV_push_constant_bank" ) || ( extension == "VK_EXT_ray_tracing_invocation_reorder" ) ||
+           ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) ||
+           ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) ||
+           ( extension == "VK_KHR_video_encode_feedback2" ) || ( extension == "VK_IMG_filter_linear_2d" )
 #if defined( VK_USE_PLATFORM_METAL_EXT )
         || ( extension == "VK_EXT_external_memory_metal" )
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
         || ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_ARM_performance_counters_by_region" ) ||
-           ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_ARM_format_pack" ) ||
-           ( extension == "VK_VALVE_fragment_density_map_layered" ) || ( extension == "VK_KHR_robustness2" )
-#if defined( VK_ENABLE_BETA_EXTENSIONS )
-        || ( extension == "VK_NV_present_metering" )
-#endif /*VK_ENABLE_BETA_EXTENSIONS*/
-        || ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) ||
-           ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) ||
-           ( extension == "VK_EXT_custom_resolve" ) || ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) ||
+           ( extension == "VK_ARM_shader_instrumentation" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_ARM_format_pack" ) ||
+           ( extension == "VK_VALVE_fragment_density_map_layered" ) || ( extension == "VK_KHR_robustness2" ) || ( extension == "VK_NV_present_metering" ) ||
+           ( extension == "VK_EXT_multisampled_render_to_swapchain" ) || ( extension == "VK_EXT_fragment_density_map_offset" ) ||
+           ( extension == "VK_EXT_zero_initialize_device_memory" ) || ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) ||
+           ( extension == "VK_KHR_opacity_micromap" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) || ( extension == "VK_EXT_custom_resolve" ) ||
+           ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) || ( extension == "VK_ARM_data_graph_optical_flow" ) ||
            ( extension == "VK_EXT_shader_long_vector" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
-           ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" );
+           ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" ) ||
+           ( extension == "VK_KHR_maintenance11" ) || ( extension == "VK_EXT_cooperative_matrix_maintenance1" ) ||
+           ( extension == "VK_EXT_shader_subgroup_partitioned" ) || ( extension == "VK_KHR_extended_flags" ) ||
+           ( extension == "VK_EXT_shader_ocp_microscaling_types" ) || ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) ||
+           ( extension == "VK_SEC_throttle_hint" ) || ( extension == "VK_ARM_data_graph_neural_accelerator_statistics" ) ||
+           ( extension == "VK_EXT_primitive_restart_index" ) || ( extension == "VK_EXT_image_tiling_control" ) ||
+           ( extension == "VK_NV_cooperative_matrix_decode_vector" ) || ( extension == "VK_NV_private_data_base_handle" );
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@@ -4063,6 +4377,9 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_OHOS )
         || ( extension == "VK_OHOS_surface" )
 #endif /*VK_USE_PLATFORM_OHOS*/
+#if defined( VK_USE_PLATFORM_UBM_SEC )
+        || ( extension == "VK_SEC_ubm_surface" )
+#endif /*VK_USE_PLATFORM_UBM_SEC*/
       ;
   }
 
@@ -4096,7 +4413,8 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
            ( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || ( extension == "VK_KHR_global_priority" ) ||
            ( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_EXT_pipeline_creation_feedback" ) ||
-           ( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) ||
+           ( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) ||
+           ( extension == "VK_NV_shader_subgroup_partitioned" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) ||
            ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) ||
            ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_KHR_vulkan_memory_model" ) ||
            ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_scalar_block_layout" ) ||
@@ -4111,13 +4429,13 @@ namespace VULKAN_HPP_NAMESPACE
            ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) ||
            ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) ||
            ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) ||
-           ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) ||
-           ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) ||
-           ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_global_priority_query" ) ||
-           ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) ||
-           ( extension == "VK_EXT_depth_clamp_zero_one" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) ||
-           ( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) ||
-           ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
+           ( extension == "VK_EXT_device_fault" ) || ( extension == "VK_ARM_rasterization_order_attachment_access" ) ||
+           ( extension == "VK_VALVE_mutable_descriptor_type" ) || ( extension == "VK_KHR_format_feature_flags2" ) ||
+           ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) ||
+           ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_opacity_micromap" ) || ( extension == "VK_EXT_load_store_op_none" ) ||
+           ( extension == "VK_KHR_maintenance4" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) ||
+           ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) ||
+           ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
            ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
            ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) ||
            ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||

third_party/vulkan/vulkan_format_traits.hpp

@@ -1,5 +1,4 @@
 // Copyright 2015-2026 The Khronos Group Inc.
-//
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
 
@@ -8,7 +7,11 @@
 #ifndef VULKAN_FORMAT_TRAITS_HPP
 #define VULKAN_FORMAT_TRAITS_HPP
 
+#if defined( VULKAN_HPP_CXX_MODULE )
+#  define VULKAN_HPP_EXPORT export
+#else
 #  include <vulkan/vulkan.hpp>
+#endif
 
 namespace VULKAN_HPP_NAMESPACE
 {
@@ -19,92 +22,92 @@ namespace VULKAN_HPP_NAMESPACE
   //=== Function Declarations ===
 
   // The three-dimensional extent of a texel block.
-  VULKAN_HPP_CONSTEXPR_14 std::array<uint8_t, 3> blockExtent( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 std::array<uint8_t, 3> blockExtent( Format format );
 
   // The texel block size in bytes.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( Format format );
 
   // The class of the format (can't be just named "class"!)
-  VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( Format format );
 
   // The number of bits in this component, if not compressed, otherwise 0.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( Format format, uint8_t component );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( Format format, uint8_t component );
 
   // The number of components of this format.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( Format format );
 
   // The name of the component
-  VULKAN_HPP_CONSTEXPR_14 char const * componentName( Format format, uint8_t component );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 char const * componentName( Format format, uint8_t component );
 
   // The numeric format of the component
-  VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( Format format, uint8_t component );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( Format format, uint8_t component );
 
   // The plane this component lies in.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( Format format, uint8_t component );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( Format format, uint8_t component );
 
   // True, if the components of this format are compressed, otherwise false.
-  VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( Format format );
 
   // A textual description of the compression scheme, or an empty string if it is not compressed
-  VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( Format format );
 
   // Get all formats
-  std::vector<Format> const & getAllFormats();
+  VULKAN_HPP_EXPORT std::vector<Format> const & getAllFormats();
 
   // Get all color with a color component
-  std::vector<Format> const & getColorFormats();
+  VULKAN_HPP_EXPORT std::vector<Format> const & getColorFormats();
 
   // Get all formats with a depth component
-  std::vector<Format> const & getDepthFormats();
+  VULKAN_HPP_EXPORT std::vector<Format> const & getDepthFormats();
 
   // Get all formats with a depth and a stencil component
-  std::vector<Format> const & getDepthStencilFormats();
+  VULKAN_HPP_EXPORT std::vector<Format> const & getDepthStencilFormats();
 
   // Get all formats with a stencil component
-  std::vector<Format> const & getStencilFormats();
+  VULKAN_HPP_EXPORT std::vector<Format> const & getStencilFormats();
 
   // True, if this format has an alpha component
-  VULKAN_HPP_CONSTEXPR_14 bool hasAlphaComponent( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool hasAlphaComponent( Format format );
 
   // True, if this format has a blue component
-  VULKAN_HPP_CONSTEXPR_14 bool hasBlueComponent( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool hasBlueComponent( Format format );
 
   // True, if this format has a depth component
-  VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( Format format );
 
   // True, if this format has a green component
-  VULKAN_HPP_CONSTEXPR_14 bool hasGreenComponent( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool hasGreenComponent( Format format );
 
   // True, if this format has a red component
-  VULKAN_HPP_CONSTEXPR_14 bool hasRedComponent( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool hasRedComponent( Format format );
 
   // True, if this format has a stencil component
-  VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( Format format );
 
   // True, if the format is a color
-  VULKAN_HPP_CONSTEXPR_14 bool isColor( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool isColor( Format format );
 
   // True, if this format is a compressed one.
-  VULKAN_HPP_CONSTEXPR_14 bool isCompressed( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 bool isCompressed( Format format );
 
   // The number of bits into which the format is packed. A single image element in this format can be stored in the same space as a scalar type of this bit
   // width.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t packed( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t packed( Format format );
 
   // The single-plane format that this plane is compatible with.
-  VULKAN_HPP_CONSTEXPR_14 Format planeCompatibleFormat( Format format, uint8_t plane );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 Format planeCompatibleFormat( Format format, uint8_t plane );
 
   // The number of image planes of this format.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( Format format );
 
   // The relative height of this plane. A value of k means that this plane is 1/k the height of the overall format.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( Format format, uint8_t plane );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( Format format, uint8_t plane );
 
   // The relative width of this plane. A value of k means that this plane is 1/k the width of the overall format.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( Format format, uint8_t plane );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( Format format, uint8_t plane );
 
   // The number of texels in a texel block.
-  VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( Format format );
+  VULKAN_HPP_EXPORT VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( Format format );
 
   //=== Function Definitions ===
 
@@ -516,6 +519,9 @@ namespace VULKAN_HPP_NAMESPACE
       case Format::eAstc6x6x6SrgbBlockEXT                  : return 16;
       case Format::eAstc6x6x6SfloatBlockEXT                : return 16;
       case Format::eR8BoolARM                              : return 1;
+      case Format::eR16SfloatFpencodingBfloat16ARM         : return 2;
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM        : return 1;
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM        : return 1;
       case Format::eR16G16Sfixed5NV                        : return 4;
       case Format::eR10X6UintPack16ARM                     : return 2;
       case Format::eR10X6G10X6Uint2Pack16ARM               : return 4;
@@ -820,6 +826,9 @@ namespace VULKAN_HPP_NAMESPACE
       case Format::eAstc6x6x6SrgbBlockEXT                  : return "ASTC_6x6x6";
       case Format::eAstc6x6x6SfloatBlockEXT                : return "ASTC_6x6x6";
       case Format::eR8BoolARM                              : return "8-bit";
+      case Format::eR16SfloatFpencodingBfloat16ARM         : return "16-bit";
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM        : return "8-bit";
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM        : return "8-bit";
       case Format::eR16G16Sfixed5NV                        : return "32-bit";
       case Format::eR10X6UintPack16ARM                     : return "16-bit";
       case Format::eR10X6G10X6Uint2Pack16ARM               : return "32-bit";
@@ -2237,6 +2246,24 @@ namespace VULKAN_HPP_NAMESPACE
           case 0 : return 8;
           default: VULKAN_HPP_ASSERT( false ); return 0;
         }
+      case Format::eR16SfloatFpencodingBfloat16ARM:
+        switch ( component )
+        {
+          case 0 : return 16;
+          default: VULKAN_HPP_ASSERT( false ); return 0;
+        }
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM:
+        switch ( component )
+        {
+          case 0 : return 8;
+          default: VULKAN_HPP_ASSERT( false ); return 0;
+        }
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM:
+        switch ( component )
+        {
+          case 0 : return 8;
+          default: VULKAN_HPP_ASSERT( false ); return 0;
+        }
       case Format::eR16G16Sfixed5NV:
         switch ( component )
         {
@@ -2637,6 +2664,9 @@ namespace VULKAN_HPP_NAMESPACE
       case Format::eAstc6x6x6SrgbBlockEXT                  : return 4;
       case Format::eAstc6x6x6SfloatBlockEXT                : return 4;
       case Format::eR8BoolARM                              : return 1;
+      case Format::eR16SfloatFpencodingBfloat16ARM         : return 1;
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM        : return 1;
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM        : return 1;
       case Format::eR16G16Sfixed5NV                        : return 2;
       case Format::eR10X6UintPack16ARM                     : return 1;
       case Format::eR10X6G10X6Uint2Pack16ARM               : return 2;
@@ -4956,6 +4986,24 @@ namespace VULKAN_HPP_NAMESPACE
           case 0 : return "R";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
+      case Format::eR16SfloatFpencodingBfloat16ARM:
+        switch ( component )
+        {
+          case 0 : return "R";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM:
+        switch ( component )
+        {
+          case 0 : return "R";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM:
+        switch ( component )
+        {
+          case 0 : return "R";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
       case Format::eR16G16Sfixed5NV:
         switch ( component )
         {
@@ -7371,6 +7419,24 @@ namespace VULKAN_HPP_NAMESPACE
           case 0 : return "BOOL";
           default: VULKAN_HPP_ASSERT( false ); return "";
         }
+      case Format::eR16SfloatFpencodingBfloat16ARM:
+        switch ( component )
+        {
+          case 0 : return "SFLOAT";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM:
+        switch ( component )
+        {
+          case 0 : return "SFLOAT";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM:
+        switch ( component )
+        {
+          case 0 : return "SFLOAT";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
       case Format::eR16G16Sfixed5NV:
         switch ( component )
         {
@@ -8214,6 +8280,9 @@ namespace VULKAN_HPP_NAMESPACE
                                               Format::eAstc6x6x6SrgbBlockEXT,
                                               Format::eAstc6x6x6SfloatBlockEXT,
                                               Format::eR8BoolARM,
+                                              Format::eR16SfloatFpencodingBfloat16ARM,
+                                              Format::eR8SfloatFpencodingFloat8E4M3ARM,
+                                              Format::eR8SfloatFpencodingFloat8E5M2ARM,
                                               Format::eR16G16Sfixed5NV,
                                               Format::eR10X6UintPack16ARM,
                                               Format::eR10X6G10X6Uint2Pack16ARM,
@@ -8507,6 +8576,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                 Format::eAstc6x6x6SrgbBlockEXT,
                                                 Format::eAstc6x6x6SfloatBlockEXT,
                                                 Format::eR8BoolARM,
+                                                Format::eR16SfloatFpencodingBfloat16ARM,
+                                                Format::eR8SfloatFpencodingFloat8E4M3ARM,
+                                                Format::eR8SfloatFpencodingFloat8E5M2ARM,
                                                 Format::eR16G16Sfixed5NV,
                                                 Format::eR10X6UintPack16ARM,
                                                 Format::eR10X6G10X6Uint2Pack16ARM,
@@ -9496,6 +9568,9 @@ namespace VULKAN_HPP_NAMESPACE
       case Format::eAstc6x6x6SrgbBlockEXT:
       case Format::eAstc6x6x6SfloatBlockEXT:
       case Format::eR8BoolARM:
+      case Format::eR16SfloatFpencodingBfloat16ARM:
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM:
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM:
       case Format::eR16G16Sfixed5NV:
       case Format::eR10X6UintPack16ARM:
       case Format::eR10X6G10X6Uint2Pack16ARM:
@@ -10552,6 +10627,9 @@ namespace VULKAN_HPP_NAMESPACE
       case Format::eAstc6x6x6SrgbBlockEXT                  : return 216;
       case Format::eAstc6x6x6SfloatBlockEXT                : return 216;
       case Format::eR8BoolARM                              : return 1;
+      case Format::eR16SfloatFpencodingBfloat16ARM         : return 1;
+      case Format::eR8SfloatFpencodingFloat8E4M3ARM        : return 1;
+      case Format::eR8SfloatFpencodingFloat8E5M2ARM        : return 1;
       case Format::eR16G16Sfixed5NV                        : return 1;
       case Format::eR10X6UintPack16ARM                     : return 1;
       case Format::eR10X6G10X6Uint2Pack16ARM               : return 1;

third_party/vulkan/vulkan_fuchsia.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_ggp.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_hpp_macros.hpp

@@ -1,5 +1,4 @@
 // Copyright 2015-2026 The Khronos Group Inc.
-//
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
 
@@ -87,6 +86,23 @@
 #  define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
 #endif
 
+#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
+#  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) && !defined( VULKAN_HPP_CXX_MODULE )
+#    include <dlfcn.h>
+#  elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES )
+using HINSTANCE = struct HINSTANCE__ *;
+#    if defined( _WIN64 )
+#      include <cstdint>
+using FARPROC = int64_t( __stdcall * )();
+#    else
+using FARPROC = int( __stdcall * )();
+#    endif
+extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
+extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
+extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, char const * lpProcName );
+#  endif
+#endif
+
 #if !defined( __has_include )
 #  define __has_include( x ) false
 #endif
@@ -99,6 +115,12 @@
 #  define VULKAN_HPP_SUPPORT_SPAN
 #endif
 
+#if defined( VULKAN_HPP_CXX_MODULE )
+#  define VULKAN_HPP_EXPORT export
+#else
+#  define VULKAN_HPP_EXPORT
+#endif
+
 #if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) )
 VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." )
 #endif
@@ -175,7 +197,7 @@ VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ name
 #  else
 #    define VULKAN_HPP_CONSTEXPR_17
 #  endif
-#  if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) )
+#  if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 120000 <= GCC_VERSION ) )
 #    define VULKAN_HPP_CONSTEXPR_20 constexpr
 #  else
 #    define VULKAN_HPP_CONSTEXPR_20
@@ -233,6 +255,14 @@ VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ name
 #  define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
 #endif
 
+#if 17 <= VULKAN_HPP_CPP_VERSION
+#  define VULKAN_HPP_MAYBE_UNUSED [[maybe_unused]]
+#  define VULKAN_HPP_UNUSED( var )
+#else
+#  define VULKAN_HPP_MAYBE_UNUSED
+#  define VULKAN_HPP_UNUSED( var ) ( (void)( var ) )
+#endif
+
 #if !defined( VULKAN_HPP_NAMESPACE )
 #  define VULKAN_HPP_NAMESPACE vk
 #endif
@@ -268,20 +298,6 @@ VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ name
 #  endif
 #endif
 
-namespace VULKAN_HPP_NAMESPACE
-{
-  namespace detail
-  {
-    class DispatchLoaderDynamic;
-
-#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
-#  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-    extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
-#  endif
-#endif
-  }  // namespace detail
-}  // namespace VULKAN_HPP_NAMESPACE
-
 #if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE )
 #  define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic
 #endif
@@ -312,6 +328,8 @@ namespace VULKAN_HPP_NAMESPACE
 #    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic()
 #    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
 #  endif
+#else
+#  define VULKAN_HPP_DEFAULT_DISPATCHER_HANDLED
 #endif
 
 #if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )

third_party/vulkan/vulkan_ios.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_macos.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_metal.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_ohos.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_screen.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_shared.hpp

@@ -1,5 +1,4 @@
 // Copyright 2015-2026 The Khronos Group Inc.
-//
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
 
@@ -8,13 +7,12 @@
 #ifndef VULKAN_SHARED_HPP
 #define VULKAN_SHARED_HPP
 
-#include <vulkan/vulkan.hpp>
-
 #if !defined( VULKAN_HPP_CXX_MODULE )
 #  include <atomic>  // std::atomic_size_t
+#  include <vulkan/vulkan.hpp>
 #endif
 
-namespace VULKAN_HPP_NAMESPACE
+VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 {
 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
   template <typename HandleType>
@@ -113,8 +111,8 @@ namespace VULKAN_HPP_NAMESPACE
     {
     }
 
-    ReferenceCounter( const ReferenceCounter & )             = delete;
-    ReferenceCounter & operator=( const ReferenceCounter & ) = delete;
+    ReferenceCounter( ReferenceCounter const & )             = delete;
+    ReferenceCounter & operator=( ReferenceCounter const & ) = delete;
 
   public:
     size_t addRef() VULKAN_HPP_NOEXCEPT
@@ -148,7 +146,7 @@ namespace VULKAN_HPP_NAMESPACE
     {
     }
 
-    SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
+    SharedHandleBase( SharedHandleBase const & o ) VULKAN_HPP_NOEXCEPT
     {
       o.addRef();
       m_handle  = o.m_handle;
@@ -163,7 +161,7 @@ namespace VULKAN_HPP_NAMESPACE
       o.m_control = nullptr;
     }
 
-    SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
+    SharedHandleBase & operator=( SharedHandleBase const & o ) VULKAN_HPP_NOEXCEPT
     {
       SharedHandleBase( o ).swap( *this );
       return *this;
@@ -213,7 +211,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 #  endif
 
-    const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
+    HandleType const * operator->() const VULKAN_HPP_NOEXCEPT
     {
       return &m_handle;
     }
@@ -235,25 +233,25 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     template <typename T = HandleType>
-    typename std::enable_if<HasDestructor<T>::value, const SharedHandle<DestructorTypeOf<HandleType>> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT
+    typename std::enable_if<HasDestructor<T>::value, SharedHandle<DestructorTypeOf<HandleType>> const &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT
     {
       return getHeader().parent;
     }
 
   protected:
     template <typename T = HandleType>
-    static typename std::enable_if<!HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
+    static typename std::enable_if<!HasDestructor<T>::value, void>::type internalDestroy( HeaderType const & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
     {
       control.deleter.destroy( handle );
     }
 
     template <typename T = HandleType>
-    static typename std::enable_if<HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
+    static typename std::enable_if<HasDestructor<T>::value, void>::type internalDestroy( HeaderType const & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
     {
       control.deleter.destroy( control.parent.get(), handle );
     }
 
-    const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT
+    HeaderType const & getHeader() const VULKAN_HPP_NOEXCEPT
     {
       return m_control->m_header;
     }
@@ -295,7 +293,7 @@ namespace VULKAN_HPP_NAMESPACE
     explicit SharedHandle( HandleType                                           handle,
                            SharedHandle<DestructorTypeOf<HandleType>>           parent,
                            SharedHandle<typename GetPoolType<HandleType>::type> pool,
-                           const Dispatcher & dispatch                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+                           Dispatcher const & dispatch                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( parent ), DeleterType{ std::move( pool ), dispatch } )
     {
     }
@@ -329,13 +327,13 @@ namespace VULKAN_HPP_NAMESPACE
 
       using DestroyFunctionPointerType =
         typename std::conditional<HasDestructor<HandleType>::value,
-                                  void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
-                                  void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
+                                  void ( DestructorType::* )( HandleType, AllocationCallbacks const *, Dispatcher const & ) const,
+                                  void ( HandleType::* )( AllocationCallbacks const *, Dispatcher const & ) const>::type;
 
       using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
 
-      ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
-                           const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+      ObjectDestroyShared( Optional<AllocationCallbacks const> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
+                           Dispatcher const & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
         : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &SelectorType::destroy ) ) )
         , m_dispatch( &dispatch )
         , m_allocationCallbacks( allocationCallbacks )
@@ -359,8 +357,8 @@ namespace VULKAN_HPP_NAMESPACE
 
     private:
       DestroyFunctionPointerType          m_destroy             = nullptr;
-      const Dispatcher *                  m_dispatch            = nullptr;
-      Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+      Dispatcher const *                  m_dispatch            = nullptr;
+      Optional<AllocationCallbacks const> m_allocationCallbacks = nullptr;
     };
 
     template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -369,10 +367,10 @@ namespace VULKAN_HPP_NAMESPACE
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
+      using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, AllocationCallbacks const *, Dispatcher const & ) const;
 
-      ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
-                        const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+      ObjectFreeShared( Optional<AllocationCallbacks const> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
+                        Dispatcher const & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
         : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
         , m_dispatch( &dispatch )
         , m_allocationCallbacks( allocationCallbacks )
@@ -388,8 +386,8 @@ namespace VULKAN_HPP_NAMESPACE
 
     private:
       DestroyFunctionPointerType          m_destroy             = nullptr;
-      const Dispatcher *                  m_dispatch            = nullptr;
-      Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+      Dispatcher const *                  m_dispatch            = nullptr;
+      Optional<AllocationCallbacks const> m_allocationCallbacks = nullptr;
     };
 
     template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -398,9 +396,9 @@ namespace VULKAN_HPP_NAMESPACE
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
+      using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, Dispatcher const & ) const;
 
-      ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+      ObjectReleaseShared( Dispatcher const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
         : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::release ) ) ), m_dispatch( &dispatch )
       {
       }
@@ -414,7 +412,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     private:
       DestroyFunctionPointerType m_destroy  = nullptr;
-      const Dispatcher *         m_dispatch = nullptr;
+      Dispatcher const *         m_dispatch = nullptr;
     };
 
     template <typename HandleType, typename PoolType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -427,11 +425,11 @@ namespace VULKAN_HPP_NAMESPACE
 
       using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
 
-      using DestroyFunctionPointerType = ReturnType ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
+      using DestroyFunctionPointerType = ReturnType ( DestructorType::* )( PoolType, uint32_t, HandleType const *, Dispatcher const & ) const;
 
       PoolFreeShared() = default;
 
-      PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+      PoolFreeShared( SharedHandle<PoolType> pool, Dispatcher const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
         : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
         , m_dispatch( &dispatch )
         , m_pool( std::move( pool ) )
@@ -447,7 +445,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     private:
       DestroyFunctionPointerType m_destroy  = nullptr;
-      const Dispatcher *         m_dispatch = nullptr;
+      Dispatcher const *         m_dispatch = nullptr;
       SharedHandle<PoolType>     m_pool{};
     };
 
@@ -825,6 +823,28 @@ namespace VULKAN_HPP_NAMESPACE
 
   using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
 
+  //=== VK_AMD_gpa_interface ===
+  template <>
+  class SharedHandleTraits<GpaSessionAMD>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<GpaSessionAMD>;
+  };
+
+  using SharedGpaSessionAMD = SharedHandle<GpaSessionAMD>;
+
+  //=== VK_EXT_descriptor_heap ===
+  template <>
+  class SharedHandleTraits<TensorARM>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<TensorARM>;
+  };
+
+  using SharedTensorARM = SharedHandle<TensorARM>;
+
   //=== VK_KHR_acceleration_structure ===
   template <>
   class SharedHandleTraits<AccelerationStructureKHR>
@@ -939,16 +959,6 @@ namespace VULKAN_HPP_NAMESPACE
   using SharedMicromapEXT = SharedHandle<MicromapEXT>;
 
   //=== VK_ARM_tensors ===
-  template <>
-  class SharedHandleTraits<TensorARM>
-  {
-  public:
-    using DestructorType = Device;
-    using deleter        = detail::ObjectDestroyShared<TensorARM>;
-  };
-
-  using SharedTensorARM = SharedHandle<TensorARM>;
-
   template <>
   class SharedHandleTraits<TensorViewARM>
   {
@@ -1035,6 +1045,17 @@ namespace VULKAN_HPP_NAMESPACE
 
   using SharedIndirectExecutionSetEXT = SharedHandle<IndirectExecutionSetEXT>;
 
+  //=== VK_ARM_shader_instrumentation ===
+  template <>
+  class SharedHandleTraits<ShaderInstrumentationARM>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<ShaderInstrumentationARM>;
+  };
+
+  using SharedShaderInstrumentationARM = SharedHandle<ShaderInstrumentationARM>;
+
   // a number of SharedHandle specializations
   enum class SwapchainOwns
   {
@@ -1074,7 +1095,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   protected:
-    static void internalDestroy( const ImageHeader & control, Image handle ) VULKAN_HPP_NOEXCEPT
+    static void internalDestroy( ImageHeader const & control, Image handle ) VULKAN_HPP_NOEXCEPT
     {
       if ( control.swapchainOwned == SwapchainOwns::no )
       {
@@ -1119,7 +1140,7 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
   public:
-    const SharedHandle<SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
+    SharedHandle<SurfaceKHR> const & getSurface() const VULKAN_HPP_NOEXCEPT
     {
       return getHeader().surface;
     }
@@ -1134,13 +1155,13 @@ namespace VULKAN_HPP_NAMESPACE
   public:
     using SharedHandleBase<HandleType, DestructorType>::SharedHandleBase;
 
-    const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT
+    DestructorType const & getDestructorType() const VULKAN_HPP_NOEXCEPT
     {
       return SharedHandleBase<HandleType, DestructorType>::getHeader();
     }
 
   protected:
-    static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {}
+    static void internalDestroy( DestructorType const &, HandleType ) VULKAN_HPP_NOEXCEPT {}
   };
 
   //=== VK_VERSION_1_0 ===

third_party/vulkan/vulkan_ubm.h

@@ -0,0 +1,59 @@
+#ifndef VULKAN_UBM_H_
+#define VULKAN_UBM_H_ 1
+
+/*
+** Copyright 2015-2026 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0 OR MIT
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// VK_SEC_ubm_surface is a preprocessor guard. Do not pass it to API calls.
+#define VK_SEC_ubm_surface 1
+#define VK_SEC_UBM_SURFACE_SPEC_VERSION   1
+#define VK_SEC_UBM_SURFACE_EXTENSION_NAME "VK_SEC_ubm_surface"
+typedef VkFlags VkUbmSurfaceCreateFlagsSEC;
+typedef struct VkUbmSurfaceCreateInfoSEC {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkUbmSurfaceCreateFlagsSEC    flags;
+    struct ubm_device*            device;
+    struct ubm_surface*           surface;
+} VkUbmSurfaceCreateInfoSEC;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateUbmSurfaceSEC)(VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceUbmPresentationSupportSEC)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct ubm_device* device);
+
+#ifndef VK_NO_PROTOTYPES
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateUbmSurfaceSEC(
+    VkInstance                                  instance,
+    const VkUbmSurfaceCreateInfoSEC*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifndef VK_ONLY_EXPORTED_PROTOTYPES
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceUbmPresentationSupportSEC(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct ubm_device*                          device);
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

third_party/vulkan/vulkan_vi.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_video.cppm

@@ -1,4 +1,4 @@
-// Copyright 2021-2025 The Khronos Group Inc.
+// Copyright 2021-2026 The Khronos Group Inc.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
 
@@ -8,317 +8,66 @@ module;
 
 #define VULKAN_HPP_CXX_MODULE 1
 
+#if __has_include( <vk_video/vulkan_video_codecs_common.h> )
+#  include <vk_video/vulkan_video_codecs_common.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_h264std.h> )
+#  include <vk_video/vulkan_video_codec_h264std.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_h264std_decode.h> )
+#  include <vk_video/vulkan_video_codec_h264std_decode.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_h264std_encode.h> )
+#  include <vk_video/vulkan_video_codec_h264std_encode.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_h265std.h> )
+#  include <vk_video/vulkan_video_codec_h265std.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_h265std_decode.h> )
+#  include <vk_video/vulkan_video_codec_h265std_decode.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_h265std_encode.h> )
+#  include <vk_video/vulkan_video_codec_h265std_encode.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_vp9std.h> )
+#  include <vk_video/vulkan_video_codec_vp9std.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_vp9std_decode.h> )
+#  include <vk_video/vulkan_video_codec_vp9std_decode.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_av1std.h> )
+#  include <vk_video/vulkan_video_codec_av1std.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_av1std_decode.h> )
+#  include <vk_video/vulkan_video_codec_av1std_decode.h>
+#endif
+#if __has_include( <vk_video/vulkan_video_codec_av1std_encode.h> )
+#  include <vk_video/vulkan_video_codec_av1std_encode.h>
+#endif
+
+// clang-format off
 #include <vulkan/vulkan_hpp_macros.hpp>
+// clang-format on
 
-#if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
-#  define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \
-    "\n\tThe Vulkan-Hpp C++ named module is experimental. It is subject to change without prior notice.\n" \
-  "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \
-  "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues"
+export module vulkan_video;
 
-VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
+import std;
+import vulkan;
+
+#if defined( __clang__ )
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Winclude-angled-in-module-purview"
+#elif defined( _MSC_VER )
+#  pragma warning( push )
+#  pragma warning( disable : 5244 )
+#elif defined( __GNUC__ )
 #endif
 
 #include <vulkan/vulkan_video.hpp>
 
-export module vulkan:video;
-
-export namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE
-{
-
-  //=================
-  //=== CONSTANTs ===
-  //=================
-
-#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
-  //=== vulkan_video_codec_h264std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CpbCntListSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxChromaPlanes;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxNumListRef;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NoReferencePicture;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumElements;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumLists;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumElements;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumLists;
+#if defined( __clang__ )
+#  pragma clang diagnostic pop
+#elif defined( _MSC_VER )
+#  pragma warning( pop )
+#elif defined( __GNUC__ )
 #endif
-
-#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
-  //=== vulkan_video_codec_h264std_decode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCountListSize;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
-  //=== vulkan_video_codec_h265std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetListSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileColsListSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileRowsListSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265CpbCntListSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxChromaPlanes;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDeltaPoc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDpbSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermPics;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermRefPicsSps;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxNumListRef;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxShortTermRefPicSets;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265NoReferencePicture;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteCompEntriesListSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteComponentsListSize;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumElements;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumLists;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumElements;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumLists;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumElements;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumLists;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumElements;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumLists;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SublayersListSize;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
-  //=== vulkan_video_codec_h265std_decode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265RefPicSetListSize;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
-  //=== vulkan_video_codec_vp9std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9LoopFilterAdjustments;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxRefFrames;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationPredProb;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationTreeProbs;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegments;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9NumRefFrames;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9RefsPerFrame;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9SegLvlMax;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
-  //=== vulkan_video_codec_av1std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1GlobalMotionParams;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1LoopFilterAdjustments;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxCdefFilterStrengths;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxLoopFilterStrengths;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCbPoints;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCrPoints;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPlanes;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosChroma;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosLuma;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumYPoints;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxSegments;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileCols;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileRows;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1NumRefFrames;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1PrimaryRefNone;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1RefsPerFrame;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SegLvlMax;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectIntegerMv;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectScreenContentTools;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SkipModeFrames;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1TotalRefsPerFrame;
-#endif
-
-  //=============
-  //=== ENUMs ===
-  //=============
-
-#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
-  //=== vulkan_video_codec_h264std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
-  //=== vulkan_video_codec_h264std_decode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
-  //=== vulkan_video_codec_h265std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
-  //=== vulkan_video_codec_vp9std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Level;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ReferenceName;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
-  //=== vulkan_video_codec_av1std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode;
-#endif
-
-  //===============
-  //=== STRUCTS ===
-  //===============
-
-#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
-  //=== vulkan_video_codec_h264std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
-  //=== vulkan_video_codec_h264std_decode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ )
-  //=== vulkan_video_codec_h264std_encode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
-  //=== vulkan_video_codec_h265std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
-  //=== vulkan_video_codec_h265std_decode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ )
-  //=== vulkan_video_codec_h265std_encode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
-  //=== vulkan_video_codec_vp9std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ )
-  //=== vulkan_video_codec_vp9std_decode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
-  //=== vulkan_video_codec_av1std ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ )
-  //=== vulkan_video_codec_av1std_decode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags;
-#endif
-
-#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ )
-  //=== vulkan_video_codec_av1std_encode ===
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
-  using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
-#endif
-
-}  // namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE

third_party/vulkan/vulkan_video.hpp

@@ -1,4 +1,4 @@
-// Copyright 2021-2025 The Khronos Group Inc.
+// Copyright 2021-2026 The Khronos Group Inc.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
 
@@ -13,10 +13,8 @@
 #  define has_include_was_not_defined
 #endif
 
-// clang-format off
+#if !defined( VULKAN_HPP_CXX_MODULE )
 #  include <vulkan/vulkan.hpp>
-// clang-format on
-
 #  if __has_include( <vk_video/vulkan_video_codecs_common.h> )
 #    include <vk_video/vulkan_video_codecs_common.h>
 #  endif
@@ -54,15 +52,16 @@
 #    include <vk_video/vulkan_video_codec_av1std_encode.h>
 #  endif
 
+#endif
+
 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE )
 #  define VULKAN_HPP_VIDEO_NAMESPACE video
 #endif
 
-namespace VULKAN_HPP_NAMESPACE
+VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
 {
   namespace VULKAN_HPP_VIDEO_NAMESPACE
   {
-
     //=================
     //=== CONSTANTs ===
     //=================
@@ -174,6 +173,8 @@ namespace VULKAN_HPP_NAMESPACE
       eBaseline          = STD_VIDEO_H264_PROFILE_IDC_BASELINE,
       eMain              = STD_VIDEO_H264_PROFILE_IDC_MAIN,
       eHigh              = STD_VIDEO_H264_PROFILE_IDC_HIGH,
+      eHigh10            = STD_VIDEO_H264_PROFILE_IDC_HIGH_10,
+      eHigh422           = STD_VIDEO_H264_PROFILE_IDC_HIGH_422,
       eHigh444Predictive = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE,
       eInvalid           = STD_VIDEO_H264_PROFILE_IDC_INVALID
     };
@@ -805,7 +806,7 @@ namespace VULKAN_HPP_NAMESPACE
       uint8_t                                                                     chroma_sample_loc_type_top_field    = {};
       uint8_t                                                                     chroma_sample_loc_type_bottom_field = {};
       uint32_t                                                                    reserved1                           = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters * pHrdParameters                      = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters const * pHrdParameters                      = {};
     };
 
     struct H264SpsFlags
@@ -982,9 +983,9 @@ namespace VULKAN_HPP_NAMESPACE
       uint32_t                                                      frame_crop_top_offset                            = {};
       uint32_t                                                      frame_crop_bottom_offset                         = {};
       uint32_t                                                      reserved2                                        = {};
-      const int32_t *                                               pOffsetForRefFrame                               = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists *            pScalingLists            = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui * pSequenceParameterSetVui = {};
+      int32_t const *                                               pOffsetForRefFrame                               = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists const *            pScalingLists            = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui const * pSequenceParameterSetVui = {};
     };
 
     struct H264PpsFlags
@@ -1087,7 +1088,7 @@ namespace VULKAN_HPP_NAMESPACE
       int8_t                                                                     pic_init_qs_minus26           = {};
       int8_t                                                                     chroma_qp_index_offset        = {};
       int8_t                                                                     second_chroma_qp_index_offset = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists                 = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists const * pScalingLists                 = {};
     };
 #endif
 
@@ -1669,9 +1670,9 @@ namespace VULKAN_HPP_NAMESPACE
       uint8_t                                                                                refList1ModOpCount           = {};
       uint8_t                                                                                refPicMarkingOpCount         = {};
       ArrayWrapper1D<uint8_t, 7>                                                             reserved1                    = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry *    pRefList0ModOperations       = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry *    pRefList1ModOperations       = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations     = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry const *    pRefList0ModOperations       = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry const *    pRefList1ModOperations       = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry const * pRefPicMarkingOperations     = {};
     };
 
     struct EncodeH264PictureInfo
@@ -1721,7 +1722,7 @@ namespace VULKAN_HPP_NAMESPACE
       int32_t                                                                                PicOrderCnt = {};
       uint8_t                                                                                temporal_id = {};
       ArrayWrapper1D<uint8_t, 3>                                                             reserved1   = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists   = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo const * pRefLists   = {};
     };
 
     struct EncodeH264ReferenceInfo
@@ -1819,7 +1820,7 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0;
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc =
         VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled;
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable const * pWeightTable = {};
     };
 #endif
 
@@ -2016,8 +2017,8 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE>                         cpb_cnt_minus1                               = {};
       ArrayWrapper1D<uint16_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE>                        elemental_duration_in_tc_minus1              = {};
       ArrayWrapper1D<uint16_t, 3>                                                         reserved                                     = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal                    = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl                    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters const * pSubLayerHrdParametersNal                    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters const * pSubLayerHrdParametersVcl                    = {};
     };
 
     struct H265VpsFlags
@@ -2198,9 +2199,9 @@ namespace VULKAN_HPP_NAMESPACE
       uint32_t                                                                       vps_time_scale                    = {};
       uint32_t                                                                       vps_num_ticks_poc_diff_one_minus1 = {};
       uint32_t                                                                       reserved3                         = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr *     pDecPicBufMgr                     = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters *    pHrdParameters                    = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel                 = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr const *     pDecPicBufMgr                     = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters const *    pHrdParameters                    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel const * pProfileTierLevel                 = {};
     };
 
     struct H265ScalingLists
@@ -2387,7 +2388,7 @@ namespace VULKAN_HPP_NAMESPACE
       uint8_t                                                                     max_bits_per_min_cu_denom           = {};
       uint8_t                                                                     log2_max_mv_length_horizontal       = {};
       uint8_t                                                                     log2_max_mv_length_vertical         = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters                      = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters const * pHrdParameters                      = {};
     };
 
     struct H265PredictorPaletteEntries
@@ -2744,13 +2745,13 @@ namespace VULKAN_HPP_NAMESPACE
       uint32_t                                                                              conf_win_right_offset                         = {};
       uint32_t                                                                              conf_win_top_offset                           = {};
       uint32_t                                                                              conf_win_bottom_offset                        = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel *        pProfileTierLevel                             = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr *            pDecPicBufMgr                                 = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists *            pScalingLists                                 = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet *      pShortTermRefPicSet                           = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps *      pLongTermRefPicsSps                           = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui * pSequenceParameterSetVui                      = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries                      = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel const *        pProfileTierLevel                             = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr const *            pDecPicBufMgr                                 = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists const *            pScalingLists                                 = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet const *      pShortTermRefPicSet                           = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps const *      pLongTermRefPicsSps                           = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui const * pSequenceParameterSetVui                      = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries const * pPredictorPaletteEntries                      = {};
     };
 
     struct H265PpsFlags
@@ -2932,8 +2933,8 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE>         column_width_minus1                       = {};
       ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE>         row_height_minus1                         = {};
       uint32_t                                                                              reserved3                                 = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists *            pScalingLists                             = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries                  = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists const *            pScalingLists                             = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries const * pPredictorPaletteEntries                  = {};
     };
 #endif
 
@@ -3325,7 +3326,7 @@ namespace VULKAN_HPP_NAMESPACE
       int8_t                                                          slice_act_cr_qp_offset       = {};
       int8_t                                                          slice_qp_delta               = {};
       uint16_t                                                        reserved1                    = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable const * pWeightTable = {};
     };
 
     struct EncodeH265ReferenceListsInfoFlags
@@ -3561,9 +3562,9 @@ namespace VULKAN_HPP_NAMESPACE
       int32_t                                                           PicOrderCntVal                           = {};
       uint8_t                                                           TemporalId                               = {};
       ArrayWrapper1D<uint8_t, 7>                                        reserved1                                = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists           = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet *       pShortTermRefPicSet = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics *    pLongTermRefPics    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo const * pRefLists           = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet const *       pShortTermRefPicSet = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics const *    pLongTermRefPics    = {};
     };
 
     struct EncodeH265ReferenceInfoFlags
@@ -4019,9 +4020,9 @@ namespace VULKAN_HPP_NAMESPACE
       uint8_t                                                                   tile_cols_log2 = {};
       uint8_t                                                                   tile_rows_log2 = {};
       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  = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig const *  pColorConfig   = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter const *   pLoopFilter    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation const * pSegmentation  = {};
     };
 #endif
 
@@ -4502,10 +4503,10 @@ namespace VULKAN_HPP_NAMESPACE
       uint16_t                                                           context_update_tile_id  = {};
       uint8_t                                                            tile_size_bytes_minus_1 = {};
       ArrayWrapper1D<uint8_t, 7>                                         reserved1               = {};
-      const uint16_t *                                                   pMiColStarts            = {};
-      const uint16_t *                                                   pMiRowStarts            = {};
-      const uint16_t *                                                   pWidthInSbsMinus1       = {};
-      const uint16_t *                                                   pHeightInSbsMinus1      = {};
+      uint16_t const *                                                   pMiColStarts            = {};
+      uint16_t const *                                                   pMiRowStarts            = {};
+      uint16_t const *                                                   pWidthInSbsMinus1       = {};
+      uint16_t const *                                                   pHeightInSbsMinus1      = {};
     };
 
     struct AV1CDEF
@@ -4862,8 +4863,8 @@ namespace VULKAN_HPP_NAMESPACE
       uint8_t                                                      seq_force_integer_mv               = {};
       uint8_t                                                      seq_force_screen_content_tools     = {};
       ArrayWrapper1D<uint8_t, 5>                                   reserved1                          = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig           = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo *  pTimingInfo            = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig const * pColorConfig           = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo const *  pTimingInfo            = {};
     };
 #endif
 
@@ -5008,14 +5009,14 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayWrapper1D<uint8_t, 3>                                                reserved2           = {};
       ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES>                     OrderHints          = {};
       ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_NUM_REF_FRAMES>                    expectedFrameId     = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo *     pTileInfo           = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization       = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation       = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter *   pLoopFilter         = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF *         pCDEF               = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion *    pGlobalMotion    = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain *       pFilmGrain       = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo const *     pTileInfo           = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization const * pQuantization       = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation const * pSegmentation       = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter const *   pLoopFilter         = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF const *         pCDEF               = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration const * pLoopRestoration = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion const *    pGlobalMotion    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain const *       pFilmGrain       = {};
     };
 
     struct DecodeAV1ReferenceInfoFlags
@@ -5421,15 +5422,15 @@ namespace VULKAN_HPP_NAMESPACE
       ArrayWrapper1D<int8_t, STD_VIDEO_AV1_REFS_PER_FRAME>                      ref_frame_idx                = {};
       ArrayWrapper1D<uint8_t, 3>                                                reserved1                    = {};
       ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_REFS_PER_FRAME>                    delta_frame_id_minus_1       = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo *     pTileInfo                    = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization                = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation                = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter *   pLoopFilter                  = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF *         pCDEF                        = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration *       pLoopRestoration    = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion *          pGlobalMotion       = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader    = {};
-      const uint32_t *                                                                   pBufferRemovalTimes = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo const *     pTileInfo                    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization const * pQuantization                = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation const * pSegmentation                = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter const *   pLoopFilter                  = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF const *         pCDEF                        = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration const *       pLoopRestoration    = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion const *          pGlobalMotion       = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader const * pExtensionHeader    = {};
+      uint32_t const *                                                                   pBufferRemovalTimes = {};
     };
 
     struct EncodeAV1ReferenceInfoFlags
@@ -5514,10 +5515,9 @@ namespace VULKAN_HPP_NAMESPACE
       VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
       uint8_t                                                        OrderHint  = {};
       ArrayWrapper1D<uint8_t, 3>                                     reserved1  = {};
-      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader const * pExtensionHeader = {};
     };
 #endif
-
   }  // namespace VULKAN_HPP_VIDEO_NAMESPACE
 }  // namespace VULKAN_HPP_NAMESPACE
 

third_party/vulkan/vulkan_wayland.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_win32.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_xcb.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_xlib.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*

third_party/vulkan/vulkan_xlib_xrandr.h

@@ -4,7 +4,7 @@
 /*
 ** Copyright 2015-2026 The Khronos Group Inc.
 **
-** SPDX-License-Identifier: Apache-2.0
+** SPDX-License-Identifier: Apache-2.0 OR MIT
 */
 
 /*