diff --git a/.gitignore b/.gitignore
index 8a041878cc6..fae9a45b0aa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -91,3 +91,5 @@ docs/Doxyfile
 docs/getting_started.rst
 docs/docker.rst
 docs/tensorboard.md
+
+resources
\ No newline at end of file
diff --git a/3rdparty/README.md b/3rdparty/README.md
index 05ca13f0f04..fb665c3d562 100644
--- a/3rdparty/README.md
+++ b/3rdparty/README.md
@@ -63,7 +63,7 @@ A C++ library for performing fast approximate nearest neighbor searches in high
 dimensional spaces
 http://www.cs.ubc.ca/research/flann/
 --------------------------------------------------------------------------------
-GLEW                        2.1.0                                    MIT License
+GLEW                        2.3.1                                    MIT License
 A cross-platform open-source C/C++ extension loading library
 http://glew.sourceforge.net/
 --------------------------------------------------------------------------------
diff --git a/3rdparty/filament/filament_build.cmake b/3rdparty/filament/filament_build.cmake
index 7c0e4d7a06c..8760443128a 100644
--- a/3rdparty/filament/filament_build.cmake
+++ b/3rdparty/filament/filament_build.cmake
@@ -53,8 +53,7 @@ endif()
 ExternalProject_Add(
     ext_filament
     PREFIX filament
-    URL https://github.com/google/filament/archive/refs/tags/v1.54.0.tar.gz
-    URL_HASH SHA256=f4cb4eb81e3a5d66a9612ac131d16183e118b694f4f34c051506c523a8389e8d
+    URL https://github.com/google/filament/archive/refs/tags/v1.57.2.tar.gz
     DOWNLOAD_DIR "${OPEN3D_THIRD_PARTY_DOWNLOAD_DIR}/filament"
     UPDATE_COMMAND ""
     CMAKE_ARGS
diff --git a/3rdparty/filament/filament_download.cmake b/3rdparty/filament/filament_download.cmake
index 5cac69ab9bb..8795e5bfb91 100644
--- a/3rdparty/filament/filament_download.cmake
+++ b/3rdparty/filament/filament_download.cmake
@@ -21,8 +21,8 @@ else()
             string(APPEND lib_dir /x86_64/md)
         endif()
     elseif(APPLE)
-        set(FILAMENT_URL https://github.com/google/filament/releases/download/v1.54.0/filament-v1.54.0-mac.tgz)
-        set(FILAMENT_SHA256 9b71642bd697075110579ccb55a2e8f319b05bbd89613c72567745534936186e)
+        set(FILAMENT_URL https://github.com/google/filament/releases/download/v1.57.2/filament-v1.57.2-mac.tgz)
+        set(FILAMENT_SHA256 e827a00d7433aee45397d99d98dbe7bbe78b6cc89cb76b7b105d48d5bab4d655)
     else()      # Linux: Check glibc version and use open3d filament binary if new (Ubuntu 20.04 and similar)
         execute_process(COMMAND ldd --version OUTPUT_VARIABLE ldd_version)
         string(REGEX MATCH "([0-9]+\.)+[0-9]+" glibc_version ${ldd_version})
diff --git a/3rdparty/find_dependencies.cmake b/3rdparty/find_dependencies.cmake
index 02f7b58f3d7..fb926d36ebb 100644
--- a/3rdparty/find_dependencies.cmake
+++ b/3rdparty/find_dependencies.cmake
@@ -608,6 +608,24 @@ else()
     list(APPEND Open3D_3RDPARTY_PUBLIC_TARGETS_FROM_SYSTEM Open3D::3rdparty_eigen3)
 endif()
 
+# Vulkan-Headers
+include(${Open3D_3RDPARTY_DIR}/vulkan_headers/vulkan_headers.cmake)
+open3d_import_3rdparty_library(3rdparty_vulkan_headers
+    INCLUDE_DIRS ${VULKAN_HEADERS_INCLUDE_DIRS}
+    INCLUDE_ALL
+    DEPENDS      ext_vulkan_headers
+)
+list(APPEND Open3D_3RDPARTY_PRIVATE_TARGETS_FROM_CUSTOM Open3D::3rdparty_vulkan_headers)
+
+# Vulkan Memory Allocator
+include(${Open3D_3RDPARTY_DIR}/vkmemalloc/vkmemalloc.cmake)
+open3d_import_3rdparty_library(3rdparty_vkmemalloc
+    INCLUDE_DIRS ${VMA_INCLUDE_DIRS}
+    INCLUDE_ALL
+    DEPENDS      ext_vkmemalloc ext_vmahpp
+)
+list(APPEND Open3D_3RDPARTY_PRIVATE_TARGETS_FROM_CUSTOM Open3D::3rdparty_vkmemalloc)
+
 # Nanoflann
 if(USE_SYSTEM_NANOFLANN)
     open3d_find_package_3rdparty_library(3rdparty_nanoflann
diff --git a/3rdparty/glew/LICENSE b/3rdparty/glew/LICENSE
deleted file mode 100644
index f7078042e95..00000000000
--- a/3rdparty/glew/LICENSE
+++ /dev/null
@@ -1,73 +0,0 @@
-The OpenGL Extension Wrangler Library
-Copyright (C) 2002-2007, Milan Ikits <milan ikits[]ieee org>
-Copyright (C) 2002-2007, Marcelo E. Magallon <mmagallo[]debian org>
-Copyright (C) 2002, Lev Povalahev
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without 
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, 
-  this list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above copyright notice, 
-  this list of conditions and the following disclaimer in the documentation 
-  and/or other materials provided with the distribution.
-* The name of the author may be used to endorse or promote products 
-  derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGE.
-
-
-Mesa 3-D graphics library
-Version:  7.0
-
-Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-Copyright (c) 2007 The Khronos Group Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and/or associated documentation files (the
-"Materials"), to deal in the Materials without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Materials, and to
-permit persons to whom the Materials are furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Materials.
-
-THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
diff --git a/3rdparty/glew/include/GL/eglew.h b/3rdparty/glew/include/GL/eglew.h
index e9e5a0b297a..71091dd5d80 100644
--- a/3rdparty/glew/include/GL/eglew.h
+++ b/3rdparty/glew/include/GL/eglew.h
@@ -1,6 +1,6 @@
 /*
 ** The OpenGL Extension Wrangler Library
-** Copyright (C) 2008-2019, Nigel Stewart <nigels[]users sourceforge net>
+** Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
 ** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
 ** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
 ** Copyright (C) 2002, Lev Povalahev
@@ -157,17 +157,10 @@ typedef khronos_stime_nanoseconds_t EGLnsecsANDROID;
 struct EGLClientPixmapHI;
 struct AHardwareBuffer;
 
-#define EGL_DONT_CARE                     ((EGLint)-1)
-
-#define EGL_NO_CONTEXT                    ((EGLContext)0)
-#define EGL_NO_DISPLAY                    ((EGLDisplay)0)
-#define EGL_NO_IMAGE                      ((EGLImage)0)
-#define EGL_NO_SURFACE                    ((EGLSurface)0)
-#define EGL_NO_SYNC                       ((EGLSync)0)
-
-#define EGL_UNKNOWN                       ((EGLint)-1)
-
-#define EGL_DEFAULT_DISPLAY               ((EGLNativeDisplayType)0)
+/* Wayland types for WL_bind_wayland_display purposes */
+struct wl_buffer;
+struct wl_display;
+struct wl_resource;
 
 EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress (const char *procname);
 /* ---------------------------- EGL_VERSION_1_0 ---------------------------- */
@@ -175,6 +168,10 @@ EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress (c
 #ifndef EGL_VERSION_1_0
 #define EGL_VERSION_1_0 1
 
+#define EGL_DONT_CARE EGL_CAST(EGLint,-1)
+#define EGL_NO_CONTEXT EGL_CAST(EGLContext,0)
+#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0)
+#define EGL_NO_SURFACE EGL_CAST(EGLSurface,0)
 #define EGL_FALSE 0
 #define EGL_PBUFFER_BIT 0x0001
 #define EGL_TRUE 1
@@ -322,6 +319,7 @@ typedef EGLBoolean  ( * PFNEGLSWAPINTERVALPROC) (EGLDisplay  dpy, EGLint  interv
 #ifndef EGL_VERSION_1_2
 #define EGL_VERSION_1_2 1
 
+#define EGL_UNKNOWN EGL_CAST(EGLint,-1)
 #define EGL_OPENGL_ES_BIT 0x0001
 #define EGL_OPENVG_BIT 0x0002
 #define EGL_LUMINANCE_SIZE 0x303D
@@ -332,6 +330,7 @@ typedef EGLBoolean  ( * PFNEGLSWAPINTERVALPROC) (EGLDisplay  dpy, EGLint  interv
 #define EGL_RENDER_BUFFER 0x3086
 #define EGL_COLORSPACE 0x3087
 #define EGL_ALPHA_FORMAT 0x3088
+#define EGL_COLORSPACE_sRGB 0x3089
 #define EGL_COLORSPACE_LINEAR 0x308A
 #define EGL_ALPHA_FORMAT_NONPRE 0x308B
 #define EGL_ALPHA_FORMAT_PRE 0x308C
@@ -378,6 +377,7 @@ typedef EGLBoolean  ( * PFNEGLWAITCLIENTPROC) ( void );
 #define EGL_CONFORMANT 0x3042
 #define EGL_VG_COLORSPACE 0x3087
 #define EGL_VG_ALPHA_FORMAT 0x3088
+#define EGL_VG_COLORSPACE_sRGB 0x3089
 #define EGL_VG_COLORSPACE_LINEAR 0x308A
 #define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B
 #define EGL_VG_ALPHA_FORMAT_PRE 0x308C
@@ -392,6 +392,7 @@ typedef EGLBoolean  ( * PFNEGLWAITCLIENTPROC) ( void );
 #ifndef EGL_VERSION_1_4
 #define EGL_VERSION_1_4 1
 
+#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType,0)
 #define EGL_OPENGL_BIT 0x0008
 #define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200
 #define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400
@@ -413,6 +414,8 @@ typedef EGLContext  ( * PFNEGLGETCURRENTCONTEXTPROC) ( void );
 #ifndef EGL_VERSION_1_5
 #define EGL_VERSION_1_5 1
 
+#define EGL_NO_IMAGE EGL_CAST(EGLImage,0)
+#define EGL_NO_SYNC EGL_CAST(EGLSync,0)
 #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
 #define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001
 #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
@@ -548,6 +551,8 @@ typedef EGLClientBuffer ( * PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC) (const EG
 #ifndef EGL_ANDROID_get_frame_timestamps
 #define EGL_ANDROID_get_frame_timestamps 1
 
+#define EGL_TIMESTAMP_INVALID_ANDROID EGL_CAST(EGLnsecsANDROID,-1)
+#define EGL_TIMESTAMP_PENDING_ANDROID EGL_CAST(EGLnsecsANDROID,-2)
 #define EGL_TIMESTAMPS_ANDROID 0x3430
 #define EGL_COMPOSITE_DEADLINE_ANDROID 0x3431
 #define EGL_COMPOSITE_INTERVAL_ANDROID 0x3432
@@ -607,6 +612,7 @@ typedef EGLClientBuffer ( * PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC) (const struc
 #ifndef EGL_ANDROID_native_fence_sync
 #define EGL_ANDROID_native_fence_sync 1
 
+#define EGL_NO_NATIVE_FENCE_FD_ANDROID -1
 #define EGL_SYNC_NATIVE_FENCE_ANDROID 0x3144
 #define EGL_SYNC_NATIVE_FENCE_FD_ANDROID 0x3145
 #define EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID 0x3146
@@ -643,6 +649,17 @@ typedef EGLBoolean ( * PFNEGLPRESENTATIONTIMEANDROIDPROC) (EGLDisplay dpy, EGLSu
 
 #endif /* EGL_ANDROID_recordable */
 
+/* ----------------------- EGL_ANDROID_telemetry_hint ---------------------- */
+
+#ifndef EGL_ANDROID_telemetry_hint
+#define EGL_ANDROID_telemetry_hint 1
+
+#define EGL_TELEMETRY_HINT_ANDROID 0x3570
+
+#define EGLEW_ANDROID_telemetry_hint EGLEW_GET_VAR(__EGLEW_ANDROID_telemetry_hint)
+
+#endif /* EGL_ANDROID_telemetry_hint */
+
 /* ---------------- EGL_ANGLE_d3d_share_handle_client_buffer --------------- */
 
 #ifndef EGL_ANGLE_d3d_share_handle_client_buffer
@@ -690,6 +707,19 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLS
 
 #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */
 
+/* ---------------------- EGL_ANGLE_sync_control_rate ---------------------- */
+
+#ifndef EGL_ANGLE_sync_control_rate
+#define EGL_ANGLE_sync_control_rate 1
+
+typedef EGLBoolean ( * PFNEGLGETMSCRATEANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint* numerator, EGLint* denominator);
+
+#define eglGetMscRateANGLE EGLEW_GET_FUN(__eglewGetMscRateANGLE)
+
+#define EGLEW_ANGLE_sync_control_rate EGLEW_GET_VAR(__EGLEW_ANGLE_sync_control_rate)
+
+#endif /* EGL_ANGLE_sync_control_rate */
+
 /* ---------------------- EGL_ANGLE_window_fixed_size ---------------------- */
 
 #ifndef EGL_ANGLE_window_fixed_size
@@ -812,6 +842,17 @@ typedef EGLBoolean ( * PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_i
 
 #endif /* EGL_EXT_compositor */
 
+/* ---------------------- EGL_EXT_config_select_group ---------------------- */
+
+#ifndef EGL_EXT_config_select_group
+#define EGL_EXT_config_select_group 1
+
+#define EGL_CONFIG_SELECT_GROUP_EXT 0x34C0
+
+#define EGLEW_EXT_config_select_group EGLEW_GET_VAR(__EGLEW_EXT_config_select_group)
+
+#endif /* EGL_EXT_config_select_group */
+
 /* ------------------- EGL_EXT_create_context_robustness ------------------- */
 
 #ifndef EGL_EXT_create_context_robustness
@@ -831,6 +872,7 @@ typedef EGLBoolean ( * PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_i
 #ifndef EGL_EXT_device_base
 #define EGL_EXT_device_base 1
 
+#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0)
 #define EGL_BAD_DEVICE_EXT 0x322B
 #define EGL_DEVICE_EXT 0x322C
 
@@ -850,6 +892,17 @@ typedef EGLBoolean ( * PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_i
 
 #endif /* EGL_EXT_device_drm */
 
+/* --------------------- EGL_EXT_device_drm_render_node -------------------- */
+
+#ifndef EGL_EXT_device_drm_render_node
+#define EGL_EXT_device_drm_render_node 1
+
+#define EGL_DRM_RENDER_NODE_FILE_EXT 0x3377
+
+#define EGLEW_EXT_device_drm_render_node EGLEW_GET_VAR(__EGLEW_EXT_device_drm_render_node)
+
+#endif /* EGL_EXT_device_drm_render_node */
+
 /* ----------------------- EGL_EXT_device_enumeration ---------------------- */
 
 #ifndef EGL_EXT_device_enumeration
@@ -869,16 +922,35 @@ typedef EGLBoolean ( * PFNEGLQUERYDEVICESEXTPROC) (EGLint max_devices, EGLDevice
 #define EGL_EXT_device_openwf 1
 
 #define EGL_OPENWF_DEVICE_ID_EXT 0x3237
+#define EGL_OPENWF_DEVICE_EXT 0x333D
 
 #define EGLEW_EXT_device_openwf EGLEW_GET_VAR(__EGLEW_EXT_device_openwf)
 
 #endif /* EGL_EXT_device_openwf */
 
+/* ---------------------- EGL_EXT_device_persistent_id --------------------- */
+
+#ifndef EGL_EXT_device_persistent_id
+#define EGL_EXT_device_persistent_id 1
+
+#define EGL_DEVICE_UUID_EXT 0x335C
+#define EGL_DRIVER_UUID_EXT 0x335D
+#define EGL_DRIVER_NAME_EXT 0x335E
+
+typedef EGLBoolean ( * PFNEGLQUERYDEVICEBINARYEXTPROC) (EGLDeviceEXT device, EGLint name, EGLint max_size, void* value, EGLint* size);
+
+#define eglQueryDeviceBinaryEXT EGLEW_GET_FUN(__eglewQueryDeviceBinaryEXT)
+
+#define EGLEW_EXT_device_persistent_id EGLEW_GET_VAR(__EGLEW_EXT_device_persistent_id)
+
+#endif /* EGL_EXT_device_persistent_id */
+
 /* -------------------------- EGL_EXT_device_query ------------------------- */
 
 #ifndef EGL_EXT_device_query
 #define EGL_EXT_device_query 1
 
+#define EGL_NO_DEVICE_EXT EGL_CAST(EGLDeviceEXT,0)
 #define EGL_BAD_DEVICE_EXT 0x322B
 #define EGL_DEVICE_EXT 0x322C
 
@@ -894,6 +966,54 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBEXTPROC) (EGLDisplay dpy, EGLint
 
 #endif /* EGL_EXT_device_query */
 
+/* ----------------------- EGL_EXT_device_query_name ----------------------- */
+
+#ifndef EGL_EXT_device_query_name
+#define EGL_EXT_device_query_name 1
+
+#define EGL_RENDERER_EXT 0x335F
+
+#define EGLEW_EXT_device_query_name EGLEW_GET_VAR(__EGLEW_EXT_device_query_name)
+
+#endif /* EGL_EXT_device_query_name */
+
+/* ------------------------- EGL_EXT_display_alloc ------------------------- */
+
+#ifndef EGL_EXT_display_alloc
+#define EGL_EXT_display_alloc 1
+
+#define EGL_ALLOC_NEW_DISPLAY_EXT 0x3379
+
+typedef EGLBoolean ( * PFNEGLDESTROYDISPLAYEXTPROC) (EGLDisplay dpy);
+
+#define eglDestroyDisplayEXT EGLEW_GET_FUN(__eglewDestroyDisplayEXT)
+
+#define EGLEW_EXT_display_alloc EGLEW_GET_VAR(__EGLEW_EXT_display_alloc)
+
+#endif /* EGL_EXT_display_alloc */
+
+/* ------------------------ EGL_EXT_explicit_device ------------------------ */
+
+#ifndef EGL_EXT_explicit_device
+#define EGL_EXT_explicit_device 1
+
+#define EGL_DEVICE_EXT 0x322C
+
+#define EGLEW_EXT_explicit_device EGLEW_GET_VAR(__EGLEW_EXT_explicit_device)
+
+#endif /* EGL_EXT_explicit_device */
+
+/* -------------------- EGL_EXT_gl_colorspace_bt2020_hlg ------------------- */
+
+#ifndef EGL_EXT_gl_colorspace_bt2020_hlg
+#define EGL_EXT_gl_colorspace_bt2020_hlg 1
+
+#define EGL_GL_COLORSPACE_BT2020_HLG_EXT 0x3540
+
+#define EGLEW_EXT_gl_colorspace_bt2020_hlg EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_bt2020_hlg)
+
+#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */
+
 /* ------------------ EGL_EXT_gl_colorspace_bt2020_linear ------------------ */
 
 #ifndef EGL_EXT_gl_colorspace_bt2020_linear
@@ -1071,6 +1191,8 @@ typedef EGLBoolean ( * PFNEGLQUERYDMABUFMODIFIERSEXTPROC) (EGLDisplay dpy, EGLin
 #ifndef EGL_EXT_output_base
 #define EGL_EXT_output_base 1
 
+#define EGL_NO_OUTPUT_LAYER_EXT EGL_CAST(EGLOutputLayerEXT,0)
+#define EGL_NO_OUTPUT_PORT_EXT EGL_CAST(EGLOutputPortEXT,0)
 #define EGL_BAD_OUTPUT_LAYER_EXT 0x322D
 #define EGL_BAD_OUTPUT_PORT_EXT 0x322E
 #define EGL_SWAP_INTERVAL_EXT 0x322F
@@ -1186,6 +1308,29 @@ typedef EGLDisplay ( * PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void*
 
 #endif /* EGL_EXT_platform_x11 */
 
+/* -------------------------- EGL_EXT_platform_xcb ------------------------- */
+
+#ifndef EGL_EXT_platform_xcb
+#define EGL_EXT_platform_xcb 1
+
+#define EGL_PLATFORM_XCB_EXT 0x31DC
+#define EGL_PLATFORM_XCB_SCREEN_EXT 0x31DE
+
+#define EGLEW_EXT_platform_xcb EGLEW_GET_VAR(__EGLEW_EXT_platform_xcb)
+
+#endif /* EGL_EXT_platform_xcb */
+
+/* ------------------------- EGL_EXT_present_opaque ------------------------ */
+
+#ifndef EGL_EXT_present_opaque
+#define EGL_EXT_present_opaque 1
+
+#define EGL_PRESENT_OPAQUE_EXT 0x31DF
+
+#define EGLEW_EXT_present_opaque EGLEW_GET_VAR(__EGLEW_EXT_present_opaque)
+
+#endif /* EGL_EXT_present_opaque */
+
 /* ----------------------- EGL_EXT_protected_content ----------------------- */
 
 #ifndef EGL_EXT_protected_content
@@ -1208,6 +1353,15 @@ typedef EGLDisplay ( * PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void*
 
 #endif /* EGL_EXT_protected_surface */
 
+/* --------------- EGL_EXT_query_reset_notification_strategy --------------- */
+
+#ifndef EGL_EXT_query_reset_notification_strategy
+#define EGL_EXT_query_reset_notification_strategy 1
+
+#define EGLEW_EXT_query_reset_notification_strategy EGLEW_GET_VAR(__EGLEW_EXT_query_reset_notification_strategy)
+
+#endif /* EGL_EXT_query_reset_notification_strategy */
+
 /* ------------------- EGL_EXT_stream_consumer_egloutput ------------------- */
 
 #ifndef EGL_EXT_stream_consumer_egloutput
@@ -1254,6 +1408,37 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGLSt
 
 #endif /* EGL_EXT_surface_SMPTE2086_metadata */
 
+/* ---------------------- EGL_EXT_surface_compression ---------------------- */
+
+#ifndef EGL_EXT_surface_compression
+#define EGL_EXT_surface_compression 1
+
+#define EGL_SURFACE_COMPRESSION_PLANE1_EXT 0x328E
+#define EGL_SURFACE_COMPRESSION_PLANE2_EXT 0x328F
+#define EGL_SURFACE_COMPRESSION_EXT 0x34B0
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT 0x34B1
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT 0x34B2
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT 0x34B4
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT 0x34B5
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT 0x34B6
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT 0x34B7
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT 0x34B8
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT 0x34B9
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT 0x34BA
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT 0x34BB
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT 0x34BC
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT 0x34BD
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT 0x34BE
+#define EGL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT 0x34BF
+
+typedef EGLBoolean ( * PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC) (EGLDisplay dpy, EGLConfig config, const EGLAttrib* attrib_list, EGLint* rates, EGLint rate_size, EGLint* num_rates);
+
+#define eglQuerySupportedCompressionRatesEXT EGLEW_GET_FUN(__eglewQuerySupportedCompressionRatesEXT)
+
+#define EGLEW_EXT_surface_compression EGLEW_GET_VAR(__EGLEW_EXT_surface_compression)
+
+#endif /* EGL_EXT_surface_compression */
+
 /* -------------------- EGL_EXT_swap_buffers_with_damage ------------------- */
 
 #ifndef EGL_EXT_swap_buffers_with_damage
@@ -1606,6 +1791,7 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBKHRPROC) (EGLDisplay dpy, EGLint
 #ifndef EGL_KHR_image
 #define EGL_KHR_image 1
 
+#define EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR,0)
 #define EGL_NATIVE_PIXMAP_KHR 0x30B0
 
 typedef EGLImageKHR ( * PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint* attrib_list);
@@ -1623,6 +1809,7 @@ typedef EGLBoolean ( * PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR i
 #ifndef EGL_KHR_image_base
 #define EGL_KHR_image_base 1
 
+#define EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR,0)
 #define EGL_IMAGE_PRESERVED_KHR 0x30D2
 
 #define EGLEW_KHR_image_base EGLEW_GET_VAR(__EGLEW_KHR_image_base)
@@ -1740,6 +1927,8 @@ typedef EGLBoolean  ( * PFNEGLQUERYSURFACE64KHRPROC) (EGLDisplay  dpy, EGLSurfac
 #ifndef EGL_KHR_no_config_context
 #define EGL_KHR_no_config_context 1
 
+#define EGL_NO_CONFIG_KHR EGL_CAST(EGLConfig,0)
+
 #define EGLEW_KHR_no_config_context EGLEW_GET_VAR(__EGLEW_KHR_no_config_context)
 
 #endif /* EGL_KHR_no_config_context */
@@ -1809,6 +1998,7 @@ typedef EGLBoolean ( * PFNEGLSETDAMAGEREGIONKHRPROC) (EGLDisplay dpy, EGLSurface
 #ifndef EGL_KHR_reusable_sync
 #define EGL_KHR_reusable_sync 1
 
+#define EGL_NO_SYNC_KHR EGL_CAST(EGLSyncKHR,0)
 #define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001
 #define EGL_SYNC_STATUS_KHR 0x30F1
 #define EGL_SIGNALED_KHR 0x30F2
@@ -1840,6 +2030,7 @@ typedef EGLBoolean ( * PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync
 #ifndef EGL_KHR_stream
 #define EGL_KHR_stream 1
 
+#define EGL_NO_STREAM_KHR EGL_CAST(EGLStreamKHR,0)
 #define EGL_CONSUMER_LATENCY_USEC_KHR 0x3210
 #define EGL_PRODUCER_FRAME_KHR 0x3212
 #define EGL_CONSUMER_FRAME_KHR 0x3213
@@ -1919,6 +2110,8 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERRELEASEKHRPROC) (EGLDisplay dpy, EGLS
 #ifndef EGL_KHR_stream_cross_process_fd
 #define EGL_KHR_stream_cross_process_fd 1
 
+#define EGL_NO_FILE_DESCRIPTOR_KHR EGL_CAST(EGLNativeFileDescriptorKHR,-1)
+
 typedef EGLStreamKHR ( * PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
 typedef EGLNativeFileDescriptorKHR ( * PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
 
@@ -2277,6 +2470,41 @@ typedef EGLBoolean ( * PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface su
 
 #endif /* EGL_NV_robustness_video_memory_purge */
 
+/* -------------------- EGL_NV_stream_consumer_eglimage -------------------- */
+
+#ifndef EGL_NV_stream_consumer_eglimage
+#define EGL_NV_stream_consumer_eglimage 1
+
+#define EGL_STREAM_CONSUMER_IMAGE_NV 0x3373
+#define EGL_STREAM_IMAGE_ADD_NV 0x3374
+#define EGL_STREAM_IMAGE_REMOVE_NV 0x3375
+#define EGL_STREAM_IMAGE_AVAILABLE_NV 0x3376
+
+typedef EGLint ( * PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLTime timeout, EGLenum* event, EGLAttrib* aux);
+typedef EGLBoolean ( * PFNEGLSTREAMACQUIREIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage* pImage, EGLSync sync);
+typedef EGLBoolean ( * PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLint num_modifiers, const EGLuint64KHR* modifiers, const EGLAttrib* attrib_list);
+typedef EGLBoolean ( * PFNEGLSTREAMRELEASEIMAGENVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLImage image, EGLSync sync);
+
+#define eglQueryStreamConsumerEventNV EGLEW_GET_FUN(__eglewQueryStreamConsumerEventNV)
+#define eglStreamAcquireImageNV EGLEW_GET_FUN(__eglewStreamAcquireImageNV)
+#define eglStreamImageConsumerConnectNV EGLEW_GET_FUN(__eglewStreamImageConsumerConnectNV)
+#define eglStreamReleaseImageNV EGLEW_GET_FUN(__eglewStreamReleaseImageNV)
+
+#define EGLEW_NV_stream_consumer_eglimage EGLEW_GET_VAR(__EGLEW_NV_stream_consumer_eglimage)
+
+#endif /* EGL_NV_stream_consumer_eglimage */
+
+/* ----------- EGL_NV_stream_consumer_eglimage_use_scanout_attrib ---------- */
+
+#ifndef EGL_NV_stream_consumer_eglimage_use_scanout_attrib
+#define EGL_NV_stream_consumer_eglimage_use_scanout_attrib 1
+
+#define EGL_STREAM_CONSUMER_IMAGE_USE_SCANOUT_NV 0x3378
+
+#define EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib EGLEW_GET_VAR(__EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib)
+
+#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */
+
 /* ------------------ EGL_NV_stream_consumer_gltexture_yuv ----------------- */
 
 #ifndef EGL_NV_stream_consumer_gltexture_yuv
@@ -2554,6 +2782,7 @@ typedef EGLSyncKHR ( * PFNEGLCREATESTREAMSYNCNVPROC) (EGLDisplay dpy, EGLStreamK
 #ifndef EGL_NV_sync
 #define EGL_NV_sync 1
 
+#define EGL_NO_SYNC_NV EGL_CAST(EGLSyncNV,0)
 #define EGL_SYNC_FLUSH_COMMANDS_BIT_NV 0x0001
 #define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV 0x30E6
 #define EGL_SYNC_STATUS_NV 0x30E7
@@ -2611,6 +2840,28 @@ typedef EGLuint64NV ( * PFNEGLGETSYSTEMTIMENVPROC) (void);
 
 #endif /* EGL_NV_triple_buffer */
 
+/* ---------------------- EGL_QNX_image_native_buffer ---------------------- */
+
+#ifndef EGL_QNX_image_native_buffer
+#define EGL_QNX_image_native_buffer 1
+
+#define EGL_NATIVE_BUFFER_QNX 0x3551
+
+#define EGLEW_QNX_image_native_buffer EGLEW_GET_VAR(__EGLEW_QNX_image_native_buffer)
+
+#endif /* EGL_QNX_image_native_buffer */
+
+/* ------------------------ EGL_QNX_platform_screen ------------------------ */
+
+#ifndef EGL_QNX_platform_screen
+#define EGL_QNX_platform_screen 1
+
+#define EGL_PLATFORM_SCREEN_QNX 0x3550
+
+#define EGLEW_QNX_platform_screen EGLEW_GET_VAR(__EGLEW_QNX_platform_screen)
+
+#endif /* EGL_QNX_platform_screen */
+
 /* --------------------- EGL_TIZEN_image_native_buffer --------------------- */
 
 #ifndef EGL_TIZEN_image_native_buffer
@@ -2742,6 +2993,8 @@ EGLEW_FUN_EXPORT PFNEGLPRESENTATIONTIMEANDROIDPROC __eglewPresentationTimeANDROI
 
 EGLEW_FUN_EXPORT PFNEGLQUERYSURFACEPOINTERANGLEPROC __eglewQuerySurfacePointerANGLE;
 
+EGLEW_FUN_EXPORT PFNEGLGETMSCRATEANGLEPROC __eglewGetMscRateANGLE;
+
 EGLEW_FUN_EXPORT PFNEGLCLIENTSIGNALSYNCEXTPROC __eglewClientSignalSyncEXT;
 
 EGLEW_FUN_EXPORT PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC __eglewCompositorBindTexWindowEXT;
@@ -2754,10 +3007,14 @@ EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSWAPPOLICYEXTPROC __eglewCompositorSwapPolicyEX
 
 EGLEW_FUN_EXPORT PFNEGLQUERYDEVICESEXTPROC __eglewQueryDevicesEXT;
 
+EGLEW_FUN_EXPORT PFNEGLQUERYDEVICEBINARYEXTPROC __eglewQueryDeviceBinaryEXT;
+
 EGLEW_FUN_EXPORT PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT;
 EGLEW_FUN_EXPORT PFNEGLQUERYDEVICESTRINGEXTPROC __eglewQueryDeviceStringEXT;
 EGLEW_FUN_EXPORT PFNEGLQUERYDISPLAYATTRIBEXTPROC __eglewQueryDisplayAttribEXT;
 
+EGLEW_FUN_EXPORT PFNEGLDESTROYDISPLAYEXTPROC __eglewDestroyDisplayEXT;
+
 EGLEW_FUN_EXPORT PFNEGLQUERYDMABUFFORMATSEXTPROC __eglewQueryDmaBufFormatsEXT;
 EGLEW_FUN_EXPORT PFNEGLQUERYDMABUFMODIFIERSEXTPROC __eglewQueryDmaBufModifiersEXT;
 
@@ -2776,6 +3033,8 @@ EGLEW_FUN_EXPORT PFNEGLGETPLATFORMDISPLAYEXTPROC __eglewGetPlatformDisplayEXT;
 
 EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMEROUTPUTEXTPROC __eglewStreamConsumerOutputEXT;
 
+EGLEW_FUN_EXPORT PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC __eglewQuerySupportedCompressionRatesEXT;
+
 EGLEW_FUN_EXPORT PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC __eglewSwapBuffersWithDamageEXT;
 
 EGLEW_FUN_EXPORT PFNEGLUNSIGNALSYNCEXTPROC __eglewUnsignalSyncEXT;
@@ -2852,6 +3111,11 @@ EGLEW_FUN_EXPORT PFNEGLQUERYNATIVEWINDOWNVPROC __eglewQueryNativeWindowNV;
 
 EGLEW_FUN_EXPORT PFNEGLPOSTSUBBUFFERNVPROC __eglewPostSubBufferNV;
 
+EGLEW_FUN_EXPORT PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC __eglewQueryStreamConsumerEventNV;
+EGLEW_FUN_EXPORT PFNEGLSTREAMACQUIREIMAGENVPROC __eglewStreamAcquireImageNV;
+EGLEW_FUN_EXPORT PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC __eglewStreamImageConsumerConnectNV;
+EGLEW_FUN_EXPORT PFNEGLSTREAMRELEASEIMAGENVPROC __eglewStreamReleaseImageNV;
+
 EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC __eglewStreamConsumerGLTextureExternalAttribsNV;
 
 EGLEW_FUN_EXPORT PFNEGLSTREAMFLUSHNVPROC __eglewStreamFlushNV;
@@ -2896,10 +3160,12 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_image_native_buffer;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_native_fence_sync;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_presentation_time;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_recordable;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_telemetry_hint;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_d3d_share_handle_client_buffer;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_device_d3d;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_query_surface_pointer;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_surface_d3d_texture_2d_share_handle;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_sync_control_rate;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_window_fixed_size;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ARM_image_format;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_ARM_implicit_external_sync;
@@ -2909,12 +3175,19 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_buffer_age;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_client_extensions;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_client_sync;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_compositor;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_config_select_group;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_create_context_robustness;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_base;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_drm;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_drm_render_node;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_enumeration;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_openwf;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_persistent_id;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_query;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_query_name;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_display_alloc;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_explicit_device;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_hlg;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_linear;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_pq;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_display_p3;
@@ -2935,11 +3208,15 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_base;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_device;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_wayland;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_x11;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_xcb;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_present_opaque;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_protected_content;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_protected_surface;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_query_reset_notification_strategy;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_stream_consumer_egloutput;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_CTA861_3_metadata;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_SMPTE2086_metadata;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_compression;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_swap_buffers_with_damage;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_sync_reuse;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_yuv_surface;
@@ -3008,6 +3285,8 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_post_convert_rounding;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_post_sub_buffer;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_quadruple_buffer;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_robustness_video_memory_purge;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_consumer_eglimage;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_consumer_gltexture_yuv;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_display;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_object;
@@ -3030,6 +3309,8 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_sync;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_sync;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_system_time;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_triple_buffer;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_QNX_image_native_buffer;
+EGLEW_VAR_EXPORT GLboolean __EGLEW_QNX_platform_screen;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_TIZEN_image_native_buffer;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_TIZEN_image_native_surface;
 EGLEW_VAR_EXPORT GLboolean __EGLEW_WL_bind_wayland_display;
diff --git a/3rdparty/glew/include/GL/glew.h b/3rdparty/glew/include/GL/glew.h
index 234591bb599..90c285e8f2e 100644
--- a/3rdparty/glew/include/GL/glew.h
+++ b/3rdparty/glew/include/GL/glew.h
@@ -1,6 +1,6 @@
 /*
 ** The OpenGL Extension Wrangler Library
-** Copyright (C) 2008-2019, Nigel Stewart <nigels[]users sourceforge net>
+** Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
 ** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
 ** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
 ** Copyright (C) 2002, Lev Povalahev
@@ -81,7 +81,7 @@
 #define __glew_h__
 #define __GLEW_H__
 
-#if defined(__gl_h_) || defined(__GL_H__) || defined(_GL_H) || defined(__X_GL_H)
+#if defined(__gl_h_) || defined(__GL_H__) || defined(_GL_H) || defined(__gl_gl_h_) || defined(__X_GL_H)
 #error gl.h included before glew.h
 #endif
 #if defined(__gl2_h_)
@@ -104,6 +104,7 @@
 #define __gl2_h_
 #define __GL_H__
 #define _GL_H
+#define __gl_gl_h_
 #define __gltypes_h_
 #define __REGAL_H__
 #define __X_GL_H
@@ -141,11 +142,6 @@
 #    define APIENTRY
 #  endif
 #endif
-#ifndef GLAPI
-#  if defined(__MINGW32__) || defined(__CYGWIN__)
-#    define GLAPI extern
-#  endif
-#endif
 /* <winnt.h> */
 #ifndef CALLBACK
 #define GLEW_CALLBACK_DEFINED
@@ -220,7 +216,8 @@ typedef _W64 int ptrdiff_t;
  */
 
 #if defined(__APPLE__) || defined(__linux__)
-#  if defined(__cplusplus)
+/* GCC12 errors out when including <cstdint> with __cplusplus < 201103L */
+#  if defined(__cplusplus) && __cplusplus >= 201103L
 #    include <cstddef>
 #    include <cstdint>
 #  else
@@ -2660,7 +2657,7 @@ typedef void (GLAPIENTRY *GLDEBUGPROCAMD)(GLuint id, GLenum category, GLenum sev
 typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, void *userParam);
 typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEENABLEAMDPROC) (GLenum category, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled);
 typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTAMDPROC) (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar* buf);
-typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufsize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, GLchar* message);
+typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufsize, GLenum* categories, GLenum* severities, GLuint* ids, GLsizei* lengths, GLchar* message);
 
 #define glDebugMessageCallbackAMD GLEW_GET_FUN(__glewDebugMessageCallbackAMD)
 #define glDebugMessageEnableAMD GLEW_GET_FUN(__glewDebugMessageEnableAMD)
@@ -6210,9 +6207,11 @@ typedef void (GLAPIENTRY * PFNGLREADNPIXELSARBPROC) (GLint x, GLint y, GLsizei w
 #define GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB 0x9342
 #define GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB 0x9343
 
+typedef void (GLAPIENTRY * PFNGLEVALUATEDEPTHVALUESARBPROC) (void);
 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC) (GLenum target, GLuint start, GLsizei count, const GLfloat* v);
 typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC) (GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v);
 
+#define glEvaluateDepthValuesARB GLEW_GET_FUN(__glewEvaluateDepthValuesARB)
 #define glFramebufferSampleLocationsfvARB GLEW_GET_FUN(__glewFramebufferSampleLocationsfvARB)
 #define glNamedFramebufferSampleLocationsfvARB GLEW_GET_FUN(__glewNamedFramebufferSampleLocationsfvARB)
 
@@ -8554,6 +8553,27 @@ typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVARBPROC) (const GLshort* p);
 
 #endif /* GL_ARM_rgba8 */
 
+/* --------------------- GL_ARM_shader_core_properties --------------------- */
+
+#ifndef GL_ARM_shader_core_properties
+#define GL_ARM_shader_core_properties 1
+
+#define GL_SHADER_CORE_COUNT_ARM 0x96F0
+#define GL_SHADER_CORE_ACTIVE_COUNT_ARM 0x96F1
+#define GL_SHADER_CORE_PRESENT_MASK_ARM 0x96F2
+#define GL_SHADER_CORE_MAX_WARP_COUNT_ARM 0x96F3
+#define GL_SHADER_CORE_PIXEL_RATE_ARM 0x96F4
+#define GL_SHADER_CORE_TEXEL_RATE_ARM 0x96F5
+#define GL_SHADER_CORE_FMA_RATE_ARM 0x96F6
+
+typedef void (GLAPIENTRY * PFNGLMAXACTIVESHADERCORESARMPROC) (GLuint count);
+
+#define glMaxActiveShaderCoresARM GLEW_GET_FUN(__glewMaxActiveShaderCoresARM)
+
+#define GLEW_ARM_shader_core_properties GLEW_GET_VAR(__GLEW_ARM_shader_core_properties)
+
+#endif /* GL_ARM_shader_core_properties */
+
 /* -------------------- GL_ARM_shader_framebuffer_fetch -------------------- */
 
 #ifndef GL_ARM_shader_framebuffer_fetch
@@ -9220,6 +9240,19 @@ typedef void (GLAPIENTRY * PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC) (GLuint tex
 
 #endif /* GL_EXT_EGL_image_storage */
 
+/* ------------------ GL_EXT_EGL_image_storage_compression ----------------- */
+
+#ifndef GL_EXT_EGL_image_storage_compression
+#define GL_EXT_EGL_image_storage_compression 1
+
+#define GL_SURFACE_COMPRESSION_EXT 0x96C0
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT 0x96C1
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT 0x96C2
+
+#define GLEW_EXT_EGL_image_storage_compression GLEW_GET_VAR(__GLEW_EXT_EGL_image_storage_compression)
+
+#endif /* GL_EXT_EGL_image_storage_compression */
+
 /* ---------------------------- GL_EXT_EGL_sync ---------------------------- */
 
 #ifndef GL_EXT_EGL_sync
@@ -9437,10 +9470,8 @@ typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);
 #define GL_BUFFER_STORAGE_FLAGS_EXT 0x8220
 
 typedef void (GLAPIENTRY * PFNGLBUFFERSTORAGEEXTPROC) (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
-typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags);
 
 #define glBufferStorageEXT GLEW_GET_FUN(__glewBufferStorageEXT)
-#define glNamedBufferStorageEXT GLEW_GET_FUN(__glewNamedBufferStorageEXT)
 
 #define GLEW_EXT_buffer_storage GLEW_GET_VAR(__GLEW_EXT_buffer_storage)
 
@@ -9948,6 +9979,7 @@ typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLen
 typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
 typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
 typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERDATAEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage);
+typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags);
 typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data);
 typedef void (GLAPIENTRY * PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC) (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
 typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
@@ -10010,6 +10042,7 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFEREXTPROC) (GLuint texture, GLenum ta
 typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);
 typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
 typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
+typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit);
 typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* params);
 typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLuint* params);
 typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat param);
@@ -10163,6 +10196,7 @@ typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) (GLuint vaobj, G
 #define glMultiTexSubImage2DEXT GLEW_GET_FUN(__glewMultiTexSubImage2DEXT)
 #define glMultiTexSubImage3DEXT GLEW_GET_FUN(__glewMultiTexSubImage3DEXT)
 #define glNamedBufferDataEXT GLEW_GET_FUN(__glewNamedBufferDataEXT)
+#define glNamedBufferStorageEXT GLEW_GET_FUN(__glewNamedBufferStorageEXT)
 #define glNamedBufferSubDataEXT GLEW_GET_FUN(__glewNamedBufferSubDataEXT)
 #define glNamedCopyBufferSubDataEXT GLEW_GET_FUN(__glewNamedCopyBufferSubDataEXT)
 #define glNamedFramebufferRenderbufferEXT GLEW_GET_FUN(__glewNamedFramebufferRenderbufferEXT)
@@ -10225,6 +10259,7 @@ typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) (GLuint vaobj, G
 #define glTextureImage1DEXT GLEW_GET_FUN(__glewTextureImage1DEXT)
 #define glTextureImage2DEXT GLEW_GET_FUN(__glewTextureImage2DEXT)
 #define glTextureImage3DEXT GLEW_GET_FUN(__glewTextureImage3DEXT)
+#define glTexturePageCommitmentEXT GLEW_GET_FUN(__glewTexturePageCommitmentEXT)
 #define glTextureParameterIivEXT GLEW_GET_FUN(__glewTextureParameterIivEXT)
 #define glTextureParameterIuivEXT GLEW_GET_FUN(__glewTextureParameterIuivEXT)
 #define glTextureParameterfEXT GLEW_GET_FUN(__glewTextureParameterfEXT)
@@ -10415,7 +10450,7 @@ typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIEXTPROC) (GLenum target, GLuint i
 typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
 typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
 typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
-typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, const GLsizei* count, GLenum type, const void *const *indices, GLsizei primcount, const GLint *basevertex);
+typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, const GLsizei* count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex);
 
 #define glDrawElementsBaseVertexEXT GLEW_GET_FUN(__glewDrawElementsBaseVertexEXT)
 #define glDrawElementsInstancedBaseVertexEXT GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertexEXT)
@@ -10599,6 +10634,71 @@ typedef void (GLAPIENTRY * PFNGLLIGHTENVIEXTPROC) (GLenum pname, GLint param);
 
 #endif /* GL_EXT_fragment_lighting */
 
+/* ---------------------- GL_EXT_fragment_shading_rate --------------------- */
+
+#ifndef GL_EXT_fragment_shading_rate
+#define GL_EXT_fragment_shading_rate 1
+
+#define GL_FRAGMENT_SHADING_RATE_NON_TRIVIAL_COMBINERS_SUPPORTED_EXT 0x8F6F
+#define GL_SHADING_RATE_1X1_PIXELS_EXT 0x96A6
+#define GL_SHADING_RATE_1X2_PIXELS_EXT 0x96A7
+#define GL_SHADING_RATE_2X1_PIXELS_EXT 0x96A8
+#define GL_SHADING_RATE_2X2_PIXELS_EXT 0x96A9
+#define GL_SHADING_RATE_1X4_PIXELS_EXT 0x96AA
+#define GL_SHADING_RATE_4X1_PIXELS_EXT 0x96AB
+#define GL_SHADING_RATE_4X2_PIXELS_EXT 0x96AC
+#define GL_SHADING_RATE_2X4_PIXELS_EXT 0x96AD
+#define GL_SHADING_RATE_4X4_PIXELS_EXT 0x96AE
+#define GL_SHADING_RATE_EXT 0x96D0
+#define GL_SHADING_RATE_ATTACHMENT_EXT 0x96D1
+#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_EXT 0x96D2
+#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_EXT 0x96D3
+#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_EXT 0x96D4
+#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_EXT 0x96D5
+#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_EXT 0x96D6
+#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D7
+#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D8
+#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96D9
+#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96DA
+#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_ASPECT_RATIO_EXT 0x96DB
+#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_LAYERS_EXT 0x96DC
+#define GL_FRAGMENT_SHADING_RATE_WITH_SHADER_DEPTH_STENCIL_WRITES_SUPPORTED_EXT 0x96DD
+#define GL_FRAGMENT_SHADING_RATE_WITH_SAMPLE_MASK_SUPPORTED_EXT 0x96DE
+#define GL_FRAGMENT_SHADING_RATE_ATTACHMENT_WITH_DEFAULT_FRAMEBUFFER_SUPPORTED_EXT 0x96DF
+#define GL_FRAGMENT_SHADING_RATE_PRIMITIVE_RATE_WITH_MULTI_VIEWPORT_SUPPORTED_EXT 0x9780
+
+typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSHADINGRATEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint baseLayer, GLsizei numLayers, GLsizei texelWidth, GLsizei texelHeight);
+typedef void (GLAPIENTRY * PFNGLGETFRAGMENTSHADINGRATESEXTPROC) (GLsizei samples, GLsizei maxCount, GLsizei* count, GLenum *shadingRates);
+typedef void (GLAPIENTRY * PFNGLSHADINGRATECOMBINEROPSEXTPROC) (GLenum combinerOp0, GLenum combinerOp1);
+typedef void (GLAPIENTRY * PFNGLSHADINGRATEEXTPROC) (GLenum rate);
+
+#define glFramebufferShadingRateEXT GLEW_GET_FUN(__glewFramebufferShadingRateEXT)
+#define glGetFragmentShadingRatesEXT GLEW_GET_FUN(__glewGetFragmentShadingRatesEXT)
+#define glShadingRateCombinerOpsEXT GLEW_GET_FUN(__glewShadingRateCombinerOpsEXT)
+#define glShadingRateEXT GLEW_GET_FUN(__glewShadingRateEXT)
+
+#define GLEW_EXT_fragment_shading_rate GLEW_GET_VAR(__GLEW_EXT_fragment_shading_rate)
+
+#endif /* GL_EXT_fragment_shading_rate */
+
+/* ---------------- GL_EXT_fragment_shading_rate_attachment ---------------- */
+
+#ifndef GL_EXT_fragment_shading_rate_attachment
+#define GL_EXT_fragment_shading_rate_attachment 1
+
+#define GLEW_EXT_fragment_shading_rate_attachment GLEW_GET_VAR(__GLEW_EXT_fragment_shading_rate_attachment)
+
+#endif /* GL_EXT_fragment_shading_rate_attachment */
+
+/* ----------------- GL_EXT_fragment_shading_rate_primitive ---------------- */
+
+#ifndef GL_EXT_fragment_shading_rate_primitive
+#define GL_EXT_fragment_shading_rate_primitive 1
+
+#define GLEW_EXT_fragment_shading_rate_primitive GLEW_GET_VAR(__GLEW_EXT_fragment_shading_rate_primitive)
+
+#endif /* GL_EXT_fragment_shading_rate_primitive */
+
 /* ------------------------ GL_EXT_framebuffer_blit ------------------------ */
 
 #ifndef GL_EXT_framebuffer_blit
@@ -10617,6 +10717,21 @@ typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint srcY
 
 #endif /* GL_EXT_framebuffer_blit */
 
+/* --------------------- GL_EXT_framebuffer_blit_layers -------------------- */
+
+#ifndef GL_EXT_framebuffer_blit_layers
+#define GL_EXT_framebuffer_blit_layers 1
+
+typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERLAYEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint srcLayer, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLint dstLayer, GLbitfield mask, GLenum filter);
+typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERLAYERSEXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+
+#define glBlitFramebufferLayerEXT GLEW_GET_FUN(__glewBlitFramebufferLayerEXT)
+#define glBlitFramebufferLayersEXT GLEW_GET_FUN(__glewBlitFramebufferLayersEXT)
+
+#define GLEW_EXT_framebuffer_blit_layers GLEW_GET_VAR(__GLEW_EXT_framebuffer_blit_layers)
+
+#endif /* GL_EXT_framebuffer_blit_layers */
+
 /* --------------------- GL_EXT_framebuffer_multisample -------------------- */
 
 #ifndef GL_EXT_framebuffer_multisample
@@ -11265,6 +11380,92 @@ typedef void (GLAPIENTRY * PFNGLIMPORTMEMORYWIN32NAMEEXTPROC) (GLuint memory, GL
 
 #endif /* GL_EXT_memory_object_win32 */
 
+/* --------------------------- GL_EXT_mesh_shader -------------------------- */
+
+#ifndef GL_EXT_mesh_shader
+#define GL_EXT_mesh_shader 1
+
+#define GL_MESH_SHADER_BIT_EXT 0x00000040
+#define GL_TASK_SHADER_BIT_EXT 0x00000080
+#define GL_MAX_MESH_UNIFORM_BLOCKS_EXT 0x8E60
+#define GL_MAX_MESH_TEXTURE_IMAGE_UNITS_EXT 0x8E61
+#define GL_MAX_MESH_IMAGE_UNIFORMS_EXT 0x8E62
+#define GL_MAX_MESH_UNIFORM_COMPONENTS_EXT 0x8E63
+#define GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_EXT 0x8E64
+#define GL_MAX_MESH_ATOMIC_COUNTERS_EXT 0x8E65
+#define GL_MAX_MESH_SHADER_STORAGE_BLOCKS_EXT 0x8E66
+#define GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_EXT 0x8E67
+#define GL_MAX_TASK_UNIFORM_BLOCKS_EXT 0x8E68
+#define GL_MAX_TASK_TEXTURE_IMAGE_UNITS_EXT 0x8E69
+#define GL_MAX_TASK_IMAGE_UNIFORMS_EXT 0x8E6A
+#define GL_MAX_TASK_UNIFORM_COMPONENTS_EXT 0x8E6B
+#define GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_EXT 0x8E6C
+#define GL_MAX_TASK_ATOMIC_COUNTERS_EXT 0x8E6D
+#define GL_MAX_TASK_SHADER_STORAGE_BLOCKS_EXT 0x8E6E
+#define GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_EXT 0x8E6F
+#define GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_EXT 0x92DF
+#define GL_MAX_MESH_OUTPUT_VERTICES_EXT 0x9538
+#define GL_MESH_WORK_GROUP_SIZE_EXT 0x953E
+#define GL_TASK_WORK_GROUP_SIZE_EXT 0x953F
+#define GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_EXT 0x9543
+#define GL_MAX_MESH_MULTIVIEW_VIEW_COUNT_EXT 0x9557
+#define GL_MESH_SHADER_EXT 0x9559
+#define GL_TASK_SHADER_EXT 0x955A
+#define GL_MESH_VERTICES_OUT_EXT 0x9579
+#define GL_MESH_PRIMITIVES_OUT_EXT 0x957A
+#define GL_MESH_OUTPUT_TYPE_EXT 0x957B
+#define GL_MESH_SUBROUTINE_EXT 0x957C
+#define GL_TASK_SUBROUTINE_EXT 0x957D
+#define GL_MESH_SUBROUTINE_UNIFORM_EXT 0x957E
+#define GL_TASK_SUBROUTINE_UNIFORM_EXT 0x957F
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_EXT 0x959C
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_EXT 0x959D
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_EXT 0x959E
+#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_EXT 0x959F
+#define GL_REFERENCED_BY_MESH_SHADER_EXT 0x95A0
+#define GL_REFERENCED_BY_TASK_SHADER_EXT 0x95A1
+#define GL_MAX_TASK_WORK_GROUP_TOTAL_COUNT_EXT 0x9740
+#define GL_MAX_MESH_WORK_GROUP_TOTAL_COUNT_EXT 0x9741
+#define GL_MAX_TASK_PAYLOAD_SIZE_EXT 0x9742
+#define GL_MAX_TASK_SHARED_MEMORY_SIZE_EXT 0x9743
+#define GL_MAX_MESH_SHARED_MEMORY_SIZE_EXT 0x9744
+#define GL_MAX_TASK_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9745
+#define GL_MAX_MESH_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9746
+#define GL_MAX_MESH_OUTPUT_MEMORY_SIZE_EXT 0x9747
+#define GL_MAX_MESH_PAYLOAD_AND_OUTPUT_MEMORY_SIZE_EXT 0x9748
+#define GL_MAX_MESH_OUTPUT_COMPONENTS_EXT 0x9749
+#define GL_MAX_MESH_OUTPUT_LAYERS_EXT 0x974A
+#define GL_MAX_PREFERRED_TASK_WORK_GROUP_INVOCATIONS_EXT 0x974B
+#define GL_MAX_PREFERRED_MESH_WORK_GROUP_INVOCATIONS_EXT 0x974C
+#define GL_MESH_PREFERS_LOCAL_INVOCATION_VERTEX_OUTPUT_EXT 0x974D
+#define GL_MESH_PREFERS_LOCAL_INVOCATION_PRIMITIVE_OUTPUT_EXT 0x974E
+#define GL_MESH_PREFERS_COMPACT_VERTEX_OUTPUT_EXT 0x974F
+#define GL_MESH_PREFERS_COMPACT_PRIMITIVE_OUTPUT_EXT 0x9750
+#define GL_MAX_TASK_WORK_GROUP_COUNT_EXT 0x9751
+#define GL_MAX_MESH_WORK_GROUP_COUNT_EXT 0x9752
+#define GL_TASK_SHADER_INVOCATIONS_EXT 0x9753
+#define GL_MESH_SHADER_INVOCATIONS_EXT 0x9754
+#define GL_MESH_PRIMITIVES_GENERATED_EXT 0x9755
+#define GL_MAX_MESH_OUTPUT_PRIMITIVES_EXT 0x9756
+#define GL_MAX_MESH_WORK_GROUP_INVOCATIONS_EXT 0x9757
+#define GL_MAX_MESH_WORK_GROUP_SIZE_EXT 0x9758
+#define GL_MAX_TASK_WORK_GROUP_INVOCATIONS_EXT 0x9759
+#define GL_MAX_TASK_WORK_GROUP_SIZE_EXT 0x975A
+
+typedef void (GLAPIENTRY * PFNGLDRAWMESHTASKSEXTPROC) (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
+typedef void (GLAPIENTRY * PFNGLDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect);
+typedef void (GLAPIENTRY * PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC) (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
+typedef void (GLAPIENTRY * PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect, GLsizei drawcount, GLsizei stride);
+
+#define glDrawMeshTasksEXT GLEW_GET_FUN(__glewDrawMeshTasksEXT)
+#define glDrawMeshTasksIndirectEXT GLEW_GET_FUN(__glewDrawMeshTasksIndirectEXT)
+#define glMultiDrawMeshTasksIndirectCountEXT GLEW_GET_FUN(__glewMultiDrawMeshTasksIndirectCountEXT)
+#define glMultiDrawMeshTasksIndirectEXT GLEW_GET_FUN(__glewMultiDrawMeshTasksIndirectEXT)
+
+#define GLEW_EXT_mesh_shader GLEW_GET_VAR(__GLEW_EXT_mesh_shader)
+
+#endif /* GL_EXT_mesh_shader */
+
 /* ------------------------- GL_EXT_misc_attribute ------------------------- */
 
 #ifndef GL_EXT_misc_attribute
@@ -11798,10 +11999,12 @@ typedef void (GLAPIENTRY * PFNGLRASTERSAMPLESEXTPROC) (GLuint samples, GLboolean
 #define GL_NO_RESET_NOTIFICATION_EXT 0x8261
 #define GL_CONTEXT_ROBUST_ACCESS_EXT 0x90F3
 
+typedef GLenum (GLAPIENTRY * PFNGLGETGRAPHICSRESETSTATUSEXTPROC) (void);
 typedef void (GLAPIENTRY * PFNGLGETNUNIFORMFVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLfloat* params);
 typedef void (GLAPIENTRY * PFNGLGETNUNIFORMIVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLint* params);
 typedef void (GLAPIENTRY * PFNGLREADNPIXELSEXTPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
 
+#define glGetGraphicsResetStatusEXT GLEW_GET_FUN(__glewGetGraphicsResetStatusEXT)
 #define glGetnUniformfvEXT GLEW_GET_FUN(__glewGetnUniformfvEXT)
 #define glGetnUniformivEXT GLEW_GET_FUN(__glewGetnUniformivEXT)
 #define glReadnPixelsEXT GLEW_GET_FUN(__glewReadnPixelsEXT)
@@ -11966,6 +12169,15 @@ typedef void (GLAPIENTRY * PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC) (GLuint semapho
 
 #endif /* GL_EXT_semaphore_win32 */
 
+/* --------------------- GL_EXT_separate_depth_stencil --------------------- */
+
+#ifndef GL_EXT_separate_depth_stencil
+#define GL_EXT_separate_depth_stencil 1
+
+#define GLEW_EXT_separate_depth_stencil GLEW_GET_VAR(__GLEW_EXT_separate_depth_stencil)
+
+#endif /* GL_EXT_separate_depth_stencil */
+
 /* --------------------- GL_EXT_separate_shader_objects -------------------- */
 
 #ifndef GL_EXT_separate_shader_objects
@@ -11998,6 +12210,15 @@ typedef void (GLAPIENTRY * PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint pr
 
 #endif /* GL_EXT_separate_specular_color */
 
+/* -------------------------- GL_EXT_shader_clock -------------------------- */
+
+#ifndef GL_EXT_shader_clock
+#define GL_EXT_shader_clock 1
+
+#define GLEW_EXT_shader_clock GLEW_GET_VAR(__GLEW_EXT_shader_clock)
+
+#endif /* GL_EXT_shader_clock */
+
 /* -------------------- GL_EXT_shader_framebuffer_fetch -------------------- */
 
 #ifndef GL_EXT_shader_framebuffer_fetch
@@ -12183,6 +12404,24 @@ typedef GLsizei (GLAPIENTRY * PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) (
 
 #endif /* GL_EXT_shader_pixel_local_storage2 */
 
+/* ---------------------- GL_EXT_shader_realtime_clock --------------------- */
+
+#ifndef GL_EXT_shader_realtime_clock
+#define GL_EXT_shader_realtime_clock 1
+
+#define GLEW_EXT_shader_realtime_clock GLEW_GET_VAR(__GLEW_EXT_shader_realtime_clock)
+
+#endif /* GL_EXT_shader_realtime_clock */
+
+/* -------------------- GL_EXT_shader_samples_identical -------------------- */
+
+#ifndef GL_EXT_shader_samples_identical
+#define GL_EXT_shader_samples_identical 1
+
+#define GLEW_EXT_shader_samples_identical GLEW_GET_VAR(__GLEW_EXT_shader_samples_identical)
+
+#endif /* GL_EXT_shader_samples_identical */
+
 /* ----------------------- GL_EXT_shader_texture_lod ----------------------- */
 
 #ifndef GL_EXT_shader_texture_lod
@@ -12192,6 +12431,15 @@ typedef GLsizei (GLAPIENTRY * PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) (
 
 #endif /* GL_EXT_shader_texture_lod */
 
+/* --------------------- GL_EXT_shader_texture_samples --------------------- */
+
+#ifndef GL_EXT_shader_texture_samples
+#define GL_EXT_shader_texture_samples 1
+
+#define GLEW_EXT_shader_texture_samples GLEW_GET_VAR(__GLEW_EXT_shader_texture_samples)
+
+#endif /* GL_EXT_shader_texture_samples */
+
 /* -------------------------- GL_EXT_shadow_funcs -------------------------- */
 
 #ifndef GL_EXT_shadow_funcs
@@ -12249,10 +12497,8 @@ typedef GLsizei (GLAPIENTRY * PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) (
 #define GL_NUM_SPARSE_LEVELS_EXT 0x91AA
 
 typedef void (GLAPIENTRY * PFNGLTEXPAGECOMMITMENTEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit);
-typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit);
 
 #define glTexPageCommitmentEXT GLEW_GET_FUN(__glewTexPageCommitmentEXT)
-#define glTexturePageCommitmentEXT GLEW_GET_FUN(__glewTexturePageCommitmentEXT)
 
 #define GLEW_EXT_sparse_texture GLEW_GET_VAR(__GLEW_EXT_sparse_texture)
 
@@ -12849,6 +13095,7 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum interna
 #define GL_EXT_texture_format_BGRA8888 1
 
 #define GL_BGRA_EXT 0x80E1
+#define GL_BGRA8_EXT 0x93A1
 
 #define GLEW_EXT_texture_format_BGRA8888 GLEW_GET_VAR(__GLEW_EXT_texture_format_BGRA8888)
 
@@ -13239,6 +13486,38 @@ typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum
 
 #endif /* GL_EXT_texture_storage */
 
+/* ------------------- GL_EXT_texture_storage_compression ------------------ */
+
+#ifndef GL_EXT_texture_storage_compression
+#define GL_EXT_texture_storage_compression 1
+
+#define GL_NUM_SURFACE_COMPRESSION_FIXED_RATES_EXT 0x8F6E
+#define GL_SURFACE_COMPRESSION_EXT 0x96C0
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_NONE_EXT 0x96C1
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_DEFAULT_EXT 0x96C2
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_1BPC_EXT 0x96C4
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_2BPC_EXT 0x96C5
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_3BPC_EXT 0x96C6
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_4BPC_EXT 0x96C7
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_5BPC_EXT 0x96C8
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_6BPC_EXT 0x96C9
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_7BPC_EXT 0x96CA
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_8BPC_EXT 0x96CB
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_9BPC_EXT 0x96CC
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_10BPC_EXT 0x96CD
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_11BPC_EXT 0x96CE
+#define GL_SURFACE_COMPRESSION_FIXED_RATE_12BPC_EXT 0x96CF
+
+typedef void (GLAPIENTRY * PFNGLTEXSTORAGEATTRIBS2DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, const GLint* attrib_list);
+typedef void (GLAPIENTRY * PFNGLTEXSTORAGEATTRIBS3DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, const GLint* attrib_list);
+
+#define glTexStorageAttribs2DEXT GLEW_GET_FUN(__glewTexStorageAttribs2DEXT)
+#define glTexStorageAttribs3DEXT GLEW_GET_FUN(__glewTexStorageAttribs3DEXT)
+
+#define GLEW_EXT_texture_storage_compression GLEW_GET_VAR(__GLEW_EXT_texture_storage_compression)
+
+#endif /* GL_EXT_texture_storage_compression */
+
 /* ------------------------- GL_EXT_texture_swizzle ------------------------ */
 
 #ifndef GL_EXT_texture_swizzle
@@ -13864,6 +14143,28 @@ typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target,
 
 #endif /* GL_HP_texture_lighting */
 
+/* ------------------------ GL_HUAWEI_program_binary ----------------------- */
+
+#ifndef GL_HUAWEI_program_binary
+#define GL_HUAWEI_program_binary 1
+
+#define GL_HUAWEI_PROGRAM_BINARY 0x9771
+
+#define GLEW_HUAWEI_program_binary GLEW_GET_VAR(__GLEW_HUAWEI_program_binary)
+
+#endif /* GL_HUAWEI_program_binary */
+
+/* ------------------------ GL_HUAWEI_shader_binary ------------------------ */
+
+#ifndef GL_HUAWEI_shader_binary
+#define GL_HUAWEI_shader_binary 1
+
+#define GL_HUAWEI_SHADER_BINARY 0x9770
+
+#define GLEW_HUAWEI_shader_binary GLEW_GET_VAR(__GLEW_HUAWEI_shader_binary)
+
+#endif /* GL_HUAWEI_shader_binary */
+
 /* --------------------------- GL_IBM_cull_vertex -------------------------- */
 
 #ifndef GL_IBM_cull_vertex
@@ -14042,6 +14343,17 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC) (GLenum t
 
 #endif /* GL_IMG_program_binary */
 
+/* ------------------- GL_IMG_pvric_end_to_end_signature ------------------- */
+
+#ifndef GL_IMG_pvric_end_to_end_signature
+#define GL_IMG_pvric_end_to_end_signature 1
+
+#define GL_PVRIC_SIGNATURE_MISMATCH_IMG 0x8EA3
+
+#define GLEW_IMG_pvric_end_to_end_signature GLEW_GET_VAR(__GLEW_IMG_pvric_end_to_end_signature)
+
+#endif /* GL_IMG_pvric_end_to_end_signature */
+
 /* --------------------------- GL_IMG_read_format -------------------------- */
 
 #ifndef GL_IMG_read_format
@@ -14121,6 +14433,19 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC) (GLenum t
 
 #endif /* GL_IMG_texture_filter_cubic */
 
+/* --------------------- GL_IMG_tile_region_protection --------------------- */
+
+#ifndef GL_IMG_tile_region_protection
+#define GL_IMG_tile_region_protection 1
+
+#define GL_TRP_IMG 0x8EA0
+#define GL_TRP_ERROR_CONTEXT_RESET_IMG 0x8EA1
+#define GL_TRP_UNSUPPORTED_CONTEXT_IMG 0x8EA2
+
+#define GLEW_IMG_tile_region_protection GLEW_GET_VAR(__GLEW_IMG_tile_region_protection)
+
+#endif /* GL_IMG_tile_region_protection */
+
 /* -------------------------- GL_INGR_color_clamp -------------------------- */
 
 #ifndef GL_INGR_color_clamp
@@ -14186,6 +14511,10 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC) (GLenum t
 #ifndef GL_INTEL_framebuffer_CMAA
 #define GL_INTEL_framebuffer_CMAA 1
 
+typedef void (GLAPIENTRY * PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC) (void);
+
+#define glApplyFramebufferAttachmentCMAAINTEL GLEW_GET_FUN(__glewApplyFramebufferAttachmentCMAAINTEL)
+
 #define GLEW_INTEL_framebuffer_CMAA GLEW_GET_VAR(__GLEW_INTEL_framebuffer_CMAA)
 
 #endif /* GL_INTEL_framebuffer_CMAA */
@@ -14691,6 +15020,29 @@ typedef void (GLAPIENTRY * PFNGLREADBUFFERREGIONPROC) (GLuint region, GLint x, G
 
 #endif /* GL_MESAX_texture_stack */
 
+/* ------------------------------ GL_MESA_bgra ----------------------------- */
+
+#ifndef GL_MESA_bgra
+#define GL_MESA_bgra 1
+
+#define GL_BGR_EXT 0x80E0
+#define GL_BGRA_EXT 0x80E1
+
+#define GLEW_MESA_bgra GLEW_GET_VAR(__GLEW_MESA_bgra)
+
+#endif /* GL_MESA_bgra */
+
+/* ----------------------- GL_MESA_framebuffer_flip_x ---------------------- */
+
+#ifndef GL_MESA_framebuffer_flip_x
+#define GL_MESA_framebuffer_flip_x 1
+
+#define GL_FRAMEBUFFER_FLIP_X_MESA 0x8BBC
+
+#define GLEW_MESA_framebuffer_flip_x GLEW_GET_VAR(__GLEW_MESA_framebuffer_flip_x)
+
+#endif /* GL_MESA_framebuffer_flip_x */
+
 /* ----------------------- GL_MESA_framebuffer_flip_y ---------------------- */
 
 #ifndef GL_MESA_framebuffer_flip_y
@@ -14708,6 +15060,17 @@ typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC) (GLenum targe
 
 #endif /* GL_MESA_framebuffer_flip_y */
 
+/* ---------------------- GL_MESA_framebuffer_swap_xy ---------------------- */
+
+#ifndef GL_MESA_framebuffer_swap_xy
+#define GL_MESA_framebuffer_swap_xy 1
+
+#define GL_FRAMEBUFFER_SWAP_XY_MESA 0x8BBD
+
+#define GLEW_MESA_framebuffer_swap_xy GLEW_GET_VAR(__GLEW_MESA_framebuffer_swap_xy)
+
+#endif /* GL_MESA_framebuffer_swap_xy */
+
 /* -------------------------- GL_MESA_pack_invert -------------------------- */
 
 #ifndef GL_MESA_pack_invert
@@ -14752,6 +15115,17 @@ typedef void (GLAPIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void);
 
 #endif /* GL_MESA_shader_integer_functions */
 
+/* -------------------- GL_MESA_texture_const_bandwidth -------------------- */
+
+#ifndef GL_MESA_texture_const_bandwidth
+#define GL_MESA_texture_const_bandwidth 1
+
+#define GL_CONST_BW_TILING_MESA 0x8BBE
+
+#define GLEW_MESA_texture_const_bandwidth GLEW_GET_VAR(__GLEW_MESA_texture_const_bandwidth)
+
+#endif /* GL_MESA_texture_const_bandwidth */
+
 /* ----------------------- GL_MESA_tile_raster_order ----------------------- */
 
 #ifndef GL_MESA_tile_raster_order
@@ -14923,10 +15297,12 @@ typedef void (GLAPIENTRY * PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC) (GLbitfield gpuMa
 #define GL_NVX_progress_fence 1
 
 typedef void (GLAPIENTRY * PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC) (GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64 *fenceValueArray);
+typedef GLuint (GLAPIENTRY * PFNGLCREATEPROGRESSFENCENVXPROC) (void);
 typedef void (GLAPIENTRY * PFNGLSIGNALSEMAPHOREUI64NVXPROC) (GLuint signalGpu, GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64 *fenceValueArray);
 typedef void (GLAPIENTRY * PFNGLWAITSEMAPHOREUI64NVXPROC) (GLuint waitGpu, GLsizei fenceObjectCount, const GLuint* semaphoreArray, const GLuint64 *fenceValueArray);
 
 #define glClientWaitSemaphoreui64NVX GLEW_GET_FUN(__glewClientWaitSemaphoreui64NVX)
+#define glCreateProgressFenceNVX GLEW_GET_FUN(__glewCreateProgressFenceNVX)
 #define glSignalSemaphoreui64NVX GLEW_GET_FUN(__glewSignalSemaphoreui64NVX)
 #define glWaitSemaphoreui64NVX GLEW_GET_FUN(__glewWaitSemaphoreui64NVX)
 
@@ -16404,6 +16780,25 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREATTACHMEMORYNVPROC) (GLuint texture, GLui
 
 #endif /* GL_NV_memory_attachment */
 
+/* ----------------------- GL_NV_memory_object_sparse ---------------------- */
+
+#ifndef GL_NV_memory_object_sparse
+#define GL_NV_memory_object_sparse 1
+
+typedef void (GLAPIENTRY * PFNGLBUFFERPAGECOMMITMENTMEMNVPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit);
+typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit);
+typedef void (GLAPIENTRY * PFNGLTEXPAGECOMMITMENTMEMNVPROC) (GLenum target, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit);
+typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC) (GLuint texture, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit);
+
+#define glBufferPageCommitmentMemNV GLEW_GET_FUN(__glewBufferPageCommitmentMemNV)
+#define glNamedBufferPageCommitmentMemNV GLEW_GET_FUN(__glewNamedBufferPageCommitmentMemNV)
+#define glTexPageCommitmentMemNV GLEW_GET_FUN(__glewTexPageCommitmentMemNV)
+#define glTexturePageCommitmentMemNV GLEW_GET_FUN(__glewTexturePageCommitmentMemNV)
+
+#define GLEW_NV_memory_object_sparse GLEW_GET_VAR(__GLEW_NV_memory_object_sparse)
+
+#endif /* GL_NV_memory_object_sparse */
+
 /* --------------------------- GL_NV_mesh_shader --------------------------- */
 
 #ifndef GL_NV_mesh_shader
@@ -16828,7 +17223,7 @@ typedef void (GLAPIENTRY * PFNGLPATHCOVERDEPTHFUNCNVPROC) (GLenum zfunc);
 typedef void (GLAPIENTRY * PFNGLPATHDASHARRAYNVPROC) (GLuint path, GLsizei dashCount, const GLfloat* dashArray);
 typedef void (GLAPIENTRY * PFNGLPATHFOGGENNVPROC) (GLenum genMode);
 typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXARRAYNVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
-typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXRANGENVPROC) (GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2]);
+typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXRANGENVPROC) (GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint* baseAndCount);
 typedef void (GLAPIENTRY * PFNGLPATHGLYPHRANGENVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
 typedef void (GLAPIENTRY * PFNGLPATHGLYPHSNVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void*charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
 typedef GLenum (GLAPIENTRY * PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC) (GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
@@ -17069,6 +17464,18 @@ typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (void);
 
 #endif /* GL_NV_primitive_restart */
 
+/* ---------------------- GL_NV_primitive_shading_rate --------------------- */
+
+#ifndef GL_NV_primitive_shading_rate
+#define GL_NV_primitive_shading_rate 1
+
+#define GL_SHADING_RATE_IMAGE_PER_PRIMITIVE_NV 0x95B1
+#define GL_SHADING_RATE_IMAGE_PALETTE_COUNT_NV 0x95B2
+
+#define GLEW_NV_primitive_shading_rate GLEW_GET_VAR(__GLEW_NV_primitive_shading_rate)
+
+#endif /* GL_NV_primitive_shading_rate */
+
 /* ------------------------ GL_NV_query_resource_tag ----------------------- */
 
 #ifndef GL_NV_query_resource_tag
@@ -17508,9 +17915,10 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei cou
 typedef void (GLAPIENTRY * PFNGLBINDSHADINGRATEIMAGENVPROC) (GLuint texture);
 typedef void (GLAPIENTRY * PFNGLGETSHADINGRATEIMAGEPALETTENVPROC) (GLuint viewport, GLuint entry, GLenum* rate);
 typedef void (GLAPIENTRY * PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC) (GLenum rate, GLuint samples, GLuint index, GLint* location);
-typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEBARRIERNVPROC) (GLenum order);
+typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEBARRIERNVPROC) (GLboolean synchronize);
 typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEPALETTENVPROC) (GLuint viewport, GLuint first, GLsizei count, const GLenum* rates);
 typedef void (GLAPIENTRY * PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC) (GLenum rate, GLuint samples, const GLint* locations);
+typedef void (GLAPIENTRY * PFNGLSHADINGRATESAMPLEORDERNVPROC) (GLenum order);
 
 #define glBindShadingRateImageNV GLEW_GET_FUN(__glewBindShadingRateImageNV)
 #define glGetShadingRateImagePaletteNV GLEW_GET_FUN(__glewGetShadingRateImagePaletteNV)
@@ -17518,6 +17926,7 @@ typedef void (GLAPIENTRY * PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC) (GLenum rate
 #define glShadingRateImageBarrierNV GLEW_GET_FUN(__glewShadingRateImageBarrierNV)
 #define glShadingRateImagePaletteNV GLEW_GET_FUN(__glewShadingRateImagePaletteNV)
 #define glShadingRateSampleOrderCustomNV GLEW_GET_FUN(__glewShadingRateSampleOrderCustomNV)
+#define glShadingRateSampleOrderNV GLEW_GET_FUN(__glewShadingRateSampleOrderNV)
 
 #define GLEW_NV_shading_rate_image GLEW_GET_VAR(__GLEW_NV_shading_rate_image)
 
@@ -17928,6 +18337,29 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC) (GLuint texture
 
 #endif /* GL_NV_texture_shader3 */
 
+/* ------------------------ GL_NV_timeline_semaphore ----------------------- */
+
+#ifndef GL_NV_timeline_semaphore
+#define GL_NV_timeline_semaphore 1
+
+#define GL_TIMELINE_SEMAPHORE_VALUE_NV 0x9595
+#define GL_SEMAPHORE_TYPE_NV 0x95B3
+#define GL_SEMAPHORE_TYPE_BINARY_NV 0x95B4
+#define GL_SEMAPHORE_TYPE_TIMELINE_NV 0x95B5
+#define GL_MAX_TIMELINE_SEMAPHORE_VALUE_DIFFERENCE_NV 0x95B6
+
+typedef void (GLAPIENTRY * PFNGLCREATESEMAPHORESNVPROC) (GLsizei n, GLuint* semaphores);
+typedef void (GLAPIENTRY * PFNGLGETSEMAPHOREPARAMETERIVNVPROC) (GLuint semaphore, GLenum pname, GLint* params);
+typedef void (GLAPIENTRY * PFNGLSEMAPHOREPARAMETERIVNVPROC) (GLuint semaphore, GLenum pname, const GLint* params);
+
+#define glCreateSemaphoresNV GLEW_GET_FUN(__glewCreateSemaphoresNV)
+#define glGetSemaphoreParameterivNV GLEW_GET_FUN(__glewGetSemaphoreParameterivNV)
+#define glSemaphoreParameterivNV GLEW_GET_FUN(__glewSemaphoreParameterivNV)
+
+#define GLEW_NV_timeline_semaphore GLEW_GET_VAR(__GLEW_NV_timeline_semaphore)
+
+#endif /* GL_NV_timeline_semaphore */
+
 /* ------------------------ GL_NV_transform_feedback ----------------------- */
 
 #ifndef GL_NV_transform_feedback
@@ -18017,6 +18449,15 @@ typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKNVPROC) (void);
 
 #endif /* GL_NV_transform_feedback2 */
 
+/* ------------------- GL_NV_uniform_buffer_std430_layout ------------------ */
+
+#ifndef GL_NV_uniform_buffer_std430_layout
+#define GL_NV_uniform_buffer_std430_layout 1
+
+#define GLEW_NV_uniform_buffer_std430_layout GLEW_GET_VAR(__GLEW_NV_uniform_buffer_std430_layout)
+
+#endif /* GL_NV_uniform_buffer_std430_layout */
+
 /* ------------------ GL_NV_uniform_buffer_unified_memory ------------------ */
 
 #ifndef GL_NV_uniform_buffer_unified_memory
@@ -19167,10 +19608,12 @@ typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFEROESPROC) (GLenum target);
 #define GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES 0x8B9E
 
 typedef void (GLAPIENTRY * PFNGLCURRENTPALETTEMATRIXOESPROC) (GLuint index);
+typedef void (GLAPIENTRY * PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC) (void);
 typedef void (GLAPIENTRY * PFNGLMATRIXINDEXPOINTEROESPROC) (GLint size, GLenum type, GLsizei stride, void *pointer);
 typedef void (GLAPIENTRY * PFNGLWEIGHTPOINTEROESPROC) (GLint size, GLenum type, GLsizei stride, void *pointer);
 
 #define glCurrentPaletteMatrixOES GLEW_GET_FUN(__glewCurrentPaletteMatrixOES)
+#define glLoadPaletteFromModelViewMatrixOES GLEW_GET_FUN(__glewLoadPaletteFromModelViewMatrixOES)
 #define glMatrixIndexPointerOES GLEW_GET_FUN(__glewMatrixIndexPointerOES)
 #define glWeightPointerOES GLEW_GET_FUN(__glewWeightPointerOES)
 
@@ -20100,6 +20543,19 @@ typedef GLboolean (GLAPIENTRY * PFNGLEXTISPROGRAMBINARYQCOMPROC) (GLuint program
 
 #endif /* GL_QCOM_extended_get2 */
 
+/* ---------------------- GL_QCOM_frame_extrapolation ---------------------- */
+
+#ifndef GL_QCOM_frame_extrapolation
+#define GL_QCOM_frame_extrapolation 1
+
+typedef void (GLAPIENTRY * PFNGLEXTRAPOLATETEX2DQCOMPROC) (GLuint src1, GLuint src2, GLuint output, GLfloat scaleFactor);
+
+#define glExtrapolateTex2DQCOM GLEW_GET_FUN(__glewExtrapolateTex2DQCOM)
+
+#define GLEW_QCOM_frame_extrapolation GLEW_GET_VAR(__GLEW_QCOM_frame_extrapolation)
+
+#endif /* GL_QCOM_frame_extrapolation */
+
 /* ---------------------- GL_QCOM_framebuffer_foveated --------------------- */
 
 #ifndef GL_QCOM_framebuffer_foveated
@@ -20118,6 +20574,24 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC) (GLuint
 
 #endif /* GL_QCOM_framebuffer_foveated */
 
+/* ----------------------- GL_QCOM_motion_estimation ----------------------- */
+
+#ifndef GL_QCOM_motion_estimation
+#define GL_QCOM_motion_estimation 1
+
+#define GL_MOTION_ESTIMATION_SEARCH_BLOCK_X_QCOM 0x8C90
+#define GL_MOTION_ESTIMATION_SEARCH_BLOCK_Y_QCOM 0x8C91
+
+typedef void (GLAPIENTRY * PFNGLTEXESTIMATEMOTIONQCOMPROC) (GLuint ref, GLuint target, GLuint output);
+typedef void (GLAPIENTRY * PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC) (GLuint ref, GLuint target, GLuint output, GLuint mask);
+
+#define glTexEstimateMotionQCOM GLEW_GET_FUN(__glewTexEstimateMotionQCOM)
+#define glTexEstimateMotionRegionsQCOM GLEW_GET_FUN(__glewTexEstimateMotionRegionsQCOM)
+
+#define GLEW_QCOM_motion_estimation GLEW_GET_VAR(__GLEW_QCOM_motion_estimation)
+
+#endif /* GL_QCOM_motion_estimation */
+
 /* ---------------------- GL_QCOM_perfmon_global_mode ---------------------- */
 
 #ifndef GL_QCOM_perfmon_global_mode
@@ -20129,6 +20603,26 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC) (GLuint
 
 #endif /* GL_QCOM_perfmon_global_mode */
 
+/* ----------------------- GL_QCOM_render_sRGB_R8_RG8 ---------------------- */
+
+#ifndef GL_QCOM_render_sRGB_R8_RG8
+#define GL_QCOM_render_sRGB_R8_RG8 1
+
+#define GLEW_QCOM_render_sRGB_R8_RG8 GLEW_GET_VAR(__GLEW_QCOM_render_sRGB_R8_RG8)
+
+#endif /* GL_QCOM_render_sRGB_R8_RG8 */
+
+/* --------------------- GL_QCOM_render_shared_exponent -------------------- */
+
+#ifndef GL_QCOM_render_shared_exponent
+#define GL_QCOM_render_shared_exponent 1
+
+#define GL_RGB9_E5 0x8C3D
+
+#define GLEW_QCOM_render_shared_exponent GLEW_GET_VAR(__GLEW_QCOM_render_shared_exponent)
+
+#endif /* GL_QCOM_render_shared_exponent */
+
 /* -------------- GL_QCOM_shader_framebuffer_fetch_noncoherent ------------- */
 
 #ifndef GL_QCOM_shader_framebuffer_fetch_noncoherent
@@ -20153,6 +20647,28 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC) (void);
 
 #endif /* GL_QCOM_shader_framebuffer_fetch_rate */
 
+/* -------------------------- GL_QCOM_shading_rate ------------------------- */
+
+#ifndef GL_QCOM_shading_rate
+#define GL_QCOM_shading_rate 1
+
+#define GL_SHADING_RATE_QCOM 0x96A4
+#define GL_SHADING_RATE_PRESERVE_ASPECT_RATIO_QCOM 0x96A5
+#define GL_SHADING_RATE_1X1_PIXELS_QCOM 0x96A6
+#define GL_SHADING_RATE_1X2_PIXELS_QCOM 0x96A7
+#define GL_SHADING_RATE_2X1_PIXELS_QCOM 0x96A8
+#define GL_SHADING_RATE_2X2_PIXELS_QCOM 0x96A9
+#define GL_SHADING_RATE_4X2_PIXELS_QCOM 0x96AC
+#define GL_SHADING_RATE_4X4_PIXELS_QCOM 0x96AE
+
+typedef void (GLAPIENTRY * PFNGLSHADINGRATEQCOMPROC) (GLenum rate);
+
+#define glShadingRateQCOM GLEW_GET_FUN(__glewShadingRateQCOM)
+
+#define GLEW_QCOM_shading_rate GLEW_GET_VAR(__GLEW_QCOM_shading_rate)
+
+#endif /* GL_QCOM_shading_rate */
+
 /* ------------------------ GL_QCOM_texture_foveated ----------------------- */
 
 #ifndef GL_QCOM_texture_foveated
@@ -20174,6 +20690,17 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC) (GLuint text
 
 #endif /* GL_QCOM_texture_foveated */
 
+/* ----------------------- GL_QCOM_texture_foveated2 ----------------------- */
+
+#ifndef GL_QCOM_texture_foveated2
+#define GL_QCOM_texture_foveated2 1
+
+#define GL_TEXTURE_FOVEATED_CUTOFF_DENSITY_QCOM 0x96A0
+
+#define GLEW_QCOM_texture_foveated2 GLEW_GET_VAR(__GLEW_QCOM_texture_foveated2)
+
+#endif /* GL_QCOM_texture_foveated2 */
+
 /* --------------- GL_QCOM_texture_foveated_subsampled_layout -------------- */
 
 #ifndef GL_QCOM_texture_foveated_subsampled_layout
@@ -20186,6 +20713,17 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC) (GLuint text
 
 #endif /* GL_QCOM_texture_foveated_subsampled_layout */
 
+/* ------------------------ GL_QCOM_texture_lod_bias ----------------------- */
+
+#ifndef GL_QCOM_texture_lod_bias
+#define GL_QCOM_texture_lod_bias 1
+
+#define GL_TEXTURE_LOD_BIAS_QCOM 0x8C96
+
+#define GLEW_QCOM_texture_lod_bias GLEW_GET_VAR(__GLEW_QCOM_texture_lod_bias)
+
+#endif /* GL_QCOM_texture_lod_bias */
+
 /* ------------------------ GL_QCOM_tiled_rendering ------------------------ */
 
 #ifndef GL_QCOM_tiled_rendering
@@ -20245,6 +20783,18 @@ typedef void (GLAPIENTRY * PFNGLSTARTTILINGQCOMPROC) (GLuint x, GLuint y, GLuint
 
 #endif /* GL_QCOM_writeonly_rendering */
 
+/* ------------------------- GL_QCOM_ycbcr_degamma ------------------------- */
+
+#ifndef GL_QCOM_ycbcr_degamma
+#define GL_QCOM_ycbcr_degamma 1
+
+#define GL_TEXTURE_Y_DEGAMMA_QCOM 0x9710
+#define GL_TEXTURE_CBCR_DEGAMMA_QCOM 0x9711
+
+#define GLEW_QCOM_ycbcr_degamma GLEW_GET_VAR(__GLEW_QCOM_ycbcr_degamma)
+
+#endif /* GL_QCOM_ycbcr_degamma */
+
 /* ---------------------- GL_REGAL_ES1_0_compatibility --------------------- */
 
 #ifndef GL_REGAL_ES1_0_compatibility
@@ -23137,6 +23687,7 @@ GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB;
 GLEW_FUN_EXPORT PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB;
 GLEW_FUN_EXPORT PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB;
 
+GLEW_FUN_EXPORT PFNGLEVALUATEDEPTHVALUESARBPROC __glewEvaluateDepthValuesARB;
 GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewFramebufferSampleLocationsfvARB;
 GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewNamedFramebufferSampleLocationsfvARB;
 
@@ -23549,6 +24100,8 @@ GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB;
 GLEW_FUN_EXPORT PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB;
 GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB;
 
+GLEW_FUN_EXPORT PFNGLMAXACTIVESHADERCORESARMPROC __glewMaxActiveShaderCoresARM;
+
 GLEW_FUN_EXPORT PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI;
 
 GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI;
@@ -23671,7 +24224,6 @@ GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT;
 GLEW_FUN_EXPORT PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT;
 
 GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEEXTPROC __glewBufferStorageEXT;
-GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT;
 
 GLEW_FUN_EXPORT PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT;
 GLEW_FUN_EXPORT PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT;
@@ -23850,6 +24402,7 @@ GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT;
 GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT;
 GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT;
 GLEW_FUN_EXPORT PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT;
+GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT;
 GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT;
 GLEW_FUN_EXPORT PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT;
 GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT;
@@ -23912,6 +24465,7 @@ GLEW_FUN_EXPORT PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT;
 GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT;
 GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT;
 GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT;
+GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT;
 GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT;
 GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT;
 GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT;
@@ -24008,8 +24562,16 @@ GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT
 GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT;
 GLEW_FUN_EXPORT PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT;
 
+GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSHADINGRATEEXTPROC __glewFramebufferShadingRateEXT;
+GLEW_FUN_EXPORT PFNGLGETFRAGMENTSHADINGRATESEXTPROC __glewGetFragmentShadingRatesEXT;
+GLEW_FUN_EXPORT PFNGLSHADINGRATECOMBINEROPSEXTPROC __glewShadingRateCombinerOpsEXT;
+GLEW_FUN_EXPORT PFNGLSHADINGRATEEXTPROC __glewShadingRateEXT;
+
 GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT;
 
+GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERLAYEREXTPROC __glewBlitFramebufferLayerEXT;
+GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERLAYERSEXTPROC __glewBlitFramebufferLayersEXT;
+
 GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT;
 
 GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT;
@@ -24121,6 +24683,11 @@ GLEW_FUN_EXPORT PFNGLIMPORTMEMORYFDEXTPROC __glewImportMemoryFdEXT;
 GLEW_FUN_EXPORT PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC __glewImportMemoryWin32HandleEXT;
 GLEW_FUN_EXPORT PFNGLIMPORTMEMORYWIN32NAMEEXTPROC __glewImportMemoryWin32NameEXT;
 
+GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSEXTPROC __glewDrawMeshTasksEXT;
+GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSINDIRECTEXTPROC __glewDrawMeshTasksIndirectEXT;
+GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC __glewMultiDrawMeshTasksIndirectCountEXT;
+GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC __glewMultiDrawMeshTasksIndirectEXT;
+
 GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT;
 GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT;
 
@@ -24164,6 +24731,7 @@ GLEW_FUN_EXPORT PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTable
 GLEW_FUN_EXPORT PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV;
 GLEW_FUN_EXPORT PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT;
 
+GLEW_FUN_EXPORT PFNGLGETGRAPHICSRESETSTATUSEXTPROC __glewGetGraphicsResetStatusEXT;
 GLEW_FUN_EXPORT PFNGLGETNUNIFORMFVEXTPROC __glewGetnUniformfvEXT;
 GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVEXTPROC __glewGetnUniformivEXT;
 GLEW_FUN_EXPORT PFNGLREADNPIXELSEXTPROC __glewReadnPixelsEXT;
@@ -24216,7 +24784,6 @@ GLEW_FUN_EXPORT PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewFramebufferPi
 GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewGetFramebufferPixelLocalStorageSizeEXT;
 
 GLEW_FUN_EXPORT PFNGLTEXPAGECOMMITMENTEXTPROC __glewTexPageCommitmentEXT;
-GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT;
 
 GLEW_FUN_EXPORT PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT;
 
@@ -24260,6 +24827,9 @@ GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT;
 GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT;
 GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT;
 
+GLEW_FUN_EXPORT PFNGLTEXSTORAGEATTRIBS2DEXTPROC __glewTexStorageAttribs2DEXT;
+GLEW_FUN_EXPORT PFNGLTEXSTORAGEATTRIBS3DEXTPROC __glewTexStorageAttribs3DEXT;
+
 GLEW_FUN_EXPORT PFNGLTEXTUREVIEWEXTPROC __glewTextureViewEXT;
 
 GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT;
@@ -24388,6 +24958,8 @@ GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC __glewFramebufferT
 GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC __glewFramebufferTexture2DMultisampleIMG;
 GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC __glewRenderbufferStorageMultisampleIMG;
 
+GLEW_FUN_EXPORT PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC __glewApplyFramebufferAttachmentCMAAINTEL;
+
 GLEW_FUN_EXPORT PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL;
 GLEW_FUN_EXPORT PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL;
 GLEW_FUN_EXPORT PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL;
@@ -24482,6 +25054,7 @@ GLEW_FUN_EXPORT PFNGLLGPUINTERLOCKNVXPROC __glewLGPUInterlockNVX;
 GLEW_FUN_EXPORT PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC __glewLGPUNamedBufferSubDataNVX;
 
 GLEW_FUN_EXPORT PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC __glewClientWaitSemaphoreui64NVX;
+GLEW_FUN_EXPORT PFNGLCREATEPROGRESSFENCENVXPROC __glewCreateProgressFenceNVX;
 GLEW_FUN_EXPORT PFNGLSIGNALSEMAPHOREUI64NVXPROC __glewSignalSemaphoreui64NVX;
 GLEW_FUN_EXPORT PFNGLWAITSEMAPHOREUI64NVXPROC __glewWaitSemaphoreui64NVX;
 
@@ -24721,6 +25294,11 @@ GLEW_FUN_EXPORT PFNGLRESETMEMORYOBJECTPARAMETERNVPROC __glewResetMemoryObjectPar
 GLEW_FUN_EXPORT PFNGLTEXATTACHMEMORYNVPROC __glewTexAttachMemoryNV;
 GLEW_FUN_EXPORT PFNGLTEXTUREATTACHMEMORYNVPROC __glewTextureAttachMemoryNV;
 
+GLEW_FUN_EXPORT PFNGLBUFFERPAGECOMMITMENTMEMNVPROC __glewBufferPageCommitmentMemNV;
+GLEW_FUN_EXPORT PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC __glewNamedBufferPageCommitmentMemNV;
+GLEW_FUN_EXPORT PFNGLTEXPAGECOMMITMENTMEMNVPROC __glewTexPageCommitmentMemNV;
+GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC __glewTexturePageCommitmentMemNV;
+
 GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSINDIRECTNVPROC __glewDrawMeshTasksIndirectNV;
 GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSNVPROC __glewDrawMeshTasksNV;
 GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC __glewMultiDrawMeshTasksIndirectCountNV;
@@ -24874,6 +25452,7 @@ GLEW_FUN_EXPORT PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC __glewGetShadingRateSa
 GLEW_FUN_EXPORT PFNGLSHADINGRATEIMAGEBARRIERNVPROC __glewShadingRateImageBarrierNV;
 GLEW_FUN_EXPORT PFNGLSHADINGRATEIMAGEPALETTENVPROC __glewShadingRateImagePaletteNV;
 GLEW_FUN_EXPORT PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC __glewShadingRateSampleOrderCustomNV;
+GLEW_FUN_EXPORT PFNGLSHADINGRATESAMPLEORDERNVPROC __glewShadingRateSampleOrderNV;
 
 GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV;
 GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV;
@@ -24891,6 +25470,10 @@ GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisa
 GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV;
 GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV;
 
+GLEW_FUN_EXPORT PFNGLCREATESEMAPHORESNVPROC __glewCreateSemaphoresNV;
+GLEW_FUN_EXPORT PFNGLGETSEMAPHOREPARAMETERIVNVPROC __glewGetSemaphoreParameterivNV;
+GLEW_FUN_EXPORT PFNGLSEMAPHOREPARAMETERIVNVPROC __glewSemaphoreParameterivNV;
+
 GLEW_FUN_EXPORT PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV;
 GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV;
 GLEW_FUN_EXPORT PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV;
@@ -25097,6 +25680,7 @@ GLEW_FUN_EXPORT PFNGLMAPBUFFEROESPROC __glewMapBufferOES;
 GLEW_FUN_EXPORT PFNGLUNMAPBUFFEROESPROC __glewUnmapBufferOES;
 
 GLEW_FUN_EXPORT PFNGLCURRENTPALETTEMATRIXOESPROC __glewCurrentPaletteMatrixOES;
+GLEW_FUN_EXPORT PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC __glewLoadPaletteFromModelViewMatrixOES;
 GLEW_FUN_EXPORT PFNGLMATRIXINDEXPOINTEROESPROC __glewMatrixIndexPointerOES;
 GLEW_FUN_EXPORT PFNGLWEIGHTPOINTEROESPROC __glewWeightPointerOES;
 
@@ -25173,11 +25757,18 @@ GLEW_FUN_EXPORT PFNGLEXTGETPROGRAMSQCOMPROC __glewExtGetProgramsQCOM;
 GLEW_FUN_EXPORT PFNGLEXTGETSHADERSQCOMPROC __glewExtGetShadersQCOM;
 GLEW_FUN_EXPORT PFNGLEXTISPROGRAMBINARYQCOMPROC __glewExtIsProgramBinaryQCOM;
 
+GLEW_FUN_EXPORT PFNGLEXTRAPOLATETEX2DQCOMPROC __glewExtrapolateTex2DQCOM;
+
 GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC __glewFramebufferFoveationConfigQCOM;
 GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParametersQCOM;
 
+GLEW_FUN_EXPORT PFNGLTEXESTIMATEMOTIONQCOMPROC __glewTexEstimateMotionQCOM;
+GLEW_FUN_EXPORT PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC __glewTexEstimateMotionRegionsQCOM;
+
 GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM;
 
+GLEW_FUN_EXPORT PFNGLSHADINGRATEQCOMPROC __glewShadingRateQCOM;
+
 GLEW_FUN_EXPORT PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC __glewTextureFoveationParametersQCOM;
 
 GLEW_FUN_EXPORT PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM;
@@ -25701,6 +26292,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ARB_window_pos;
 GLEW_VAR_EXPORT GLboolean __GLEW_ARM_mali_program_binary;
 GLEW_VAR_EXPORT GLboolean __GLEW_ARM_mali_shader_binary;
 GLEW_VAR_EXPORT GLboolean __GLEW_ARM_rgba8;
+GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_core_properties;
 GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_framebuffer_fetch;
 GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_framebuffer_fetch_depth_stencil;
 GLEW_VAR_EXPORT GLboolean __GLEW_ARM_texture_unnormalized_coordinates;
@@ -25732,6 +26324,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_Cg_shader;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_array;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_external_wrap_modes;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_storage;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_storage_compression;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_sync;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_YUV_target;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_abgr;
@@ -25781,7 +26374,11 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_float_blend;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fog_coord;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_frag_depth;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_lighting;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_shading_rate;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_shading_rate_attachment;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_shading_rate_primitive;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit_layers;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_object;
@@ -25803,6 +26400,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_map_buffer_range;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object_fd;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object_win32;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_mesh_shader;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_misc_attribute;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_arrays;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_indirect;
@@ -25843,8 +26441,10 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_secondary_color;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore_fd;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore_win32;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_depth_stencil;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_shader_objects;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_specular_color;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_clock;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_framebuffer_fetch;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_framebuffer_fetch_non_coherent;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_group_vote;
@@ -25856,7 +26456,10 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_io_blocks;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_non_constant_global_initializers;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_pixel_local_storage;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_pixel_local_storage2;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_realtime_clock;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_samples_identical;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_texture_lod;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_texture_samples;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_funcs;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_samplers;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shared_texture_palette;
@@ -25912,6 +26515,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shadow_lod;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shared_exponent;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_snorm;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_storage;
+GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_storage_compression;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_swizzle;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_type_2_10_10_10_REV;
 GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_view;
@@ -25934,6 +26538,8 @@ GLEW_VAR_EXPORT GLboolean __GLEW_HP_convolution_border_modes;
 GLEW_VAR_EXPORT GLboolean __GLEW_HP_image_transform;
 GLEW_VAR_EXPORT GLboolean __GLEW_HP_occlusion_test;
 GLEW_VAR_EXPORT GLboolean __GLEW_HP_texture_lighting;
+GLEW_VAR_EXPORT GLboolean __GLEW_HUAWEI_program_binary;
+GLEW_VAR_EXPORT GLboolean __GLEW_HUAWEI_shader_binary;
 GLEW_VAR_EXPORT GLboolean __GLEW_IBM_cull_vertex;
 GLEW_VAR_EXPORT GLboolean __GLEW_IBM_multimode_draw_arrays;
 GLEW_VAR_EXPORT GLboolean __GLEW_IBM_rasterpos_clip;
@@ -25944,12 +26550,14 @@ GLEW_VAR_EXPORT GLboolean __GLEW_IMG_bindless_texture;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_framebuffer_downsample;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_multisampled_render_to_texture;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_program_binary;
+GLEW_VAR_EXPORT GLboolean __GLEW_IMG_pvric_end_to_end_signature;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_read_format;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_shader_binary;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_compression_pvrtc;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_compression_pvrtc2;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_env_enhanced_fixed_function;
 GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_filter_cubic;
+GLEW_VAR_EXPORT GLboolean __GLEW_IMG_tile_region_protection;
 GLEW_VAR_EXPORT GLboolean __GLEW_INGR_color_clamp;
 GLEW_VAR_EXPORT GLboolean __GLEW_INGR_interlace_read;
 GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_blackhole_render;
@@ -25975,11 +26583,15 @@ GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_ldr;
 GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_sliced_3d;
 GLEW_VAR_EXPORT GLboolean __GLEW_KTX_buffer_region;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESAX_texture_stack;
+GLEW_VAR_EXPORT GLboolean __GLEW_MESA_bgra;
+GLEW_VAR_EXPORT GLboolean __GLEW_MESA_framebuffer_flip_x;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_framebuffer_flip_y;
+GLEW_VAR_EXPORT GLboolean __GLEW_MESA_framebuffer_swap_xy;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_pack_invert;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_program_binary_formats;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_resize_buffers;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_shader_integer_functions;
+GLEW_VAR_EXPORT GLboolean __GLEW_MESA_texture_const_bandwidth;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_tile_raster_order;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_window_pos;
 GLEW_VAR_EXPORT GLboolean __GLEW_MESA_ycbcr_texture;
@@ -26057,6 +26669,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_instanced_arrays;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_internalformat_sample_query;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_light_max_exponent;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_memory_attachment;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_memory_object_sparse;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_mesh_shader;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_coverage;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint;
@@ -26077,6 +26690,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_point_sprite;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_polygon_mode;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_present_video;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_restart;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_shading_rate;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_query_resource_tag;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_buffer;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_buffer_front;
@@ -26126,8 +26740,10 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_rectangle_compressed;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader2;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader3;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_timeline_semaphore;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback2;
+GLEW_VAR_EXPORT GLboolean __GLEW_NV_uniform_buffer_std430_layout;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_uniform_buffer_unified_memory;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_vdpau_interop;
 GLEW_VAR_EXPORT GLboolean __GLEW_NV_vdpau_interop2;
@@ -26221,14 +26837,22 @@ GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_binning_control;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_driver_control;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_extended_get;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_extended_get2;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_frame_extrapolation;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_framebuffer_foveated;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_motion_estimation;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_perfmon_global_mode;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_render_sRGB_R8_RG8;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_render_shared_exponent;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shader_framebuffer_fetch_noncoherent;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shader_framebuffer_fetch_rate;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shading_rate;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated2;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated_subsampled_layout;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_lod_bias;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_tiled_rendering;
 GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_writeonly_rendering;
+GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_ycbcr_degamma;
 GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_0_compatibility;
 GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_1_compatibility;
 GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_enable;
@@ -26378,14 +27002,15 @@ GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint;
 /* GLEW version info */
 
 /*
-VERSION 2.2.0
+VERSION 2.3.1
 VERSION_MAJOR 2
-VERSION_MINOR 2
-VERSION_MICRO 0
+VERSION_MINOR 3
+VERSION_MICRO 1
 */
 
 /* API */
 GLEWAPI GLenum GLEWAPIENTRY glewInit (void);
+GLEWAPI GLenum GLEWAPIENTRY glewContextInit (void);
 GLEWAPI GLboolean GLEWAPIENTRY glewIsSupported (const char *name);
 #define glewIsExtensionSupported(x) glewIsSupported(x)
 
diff --git a/3rdparty/glew/include/GL/glxew.h b/3rdparty/glew/include/GL/glxew.h
index 0474ed5ed8c..2796b9b9ad9 100644
--- a/3rdparty/glew/include/GL/glxew.h
+++ b/3rdparty/glew/include/GL/glxew.h
@@ -1,6 +1,6 @@
 /*
 ** The OpenGL Extension Wrangler Library
-** Copyright (C) 2008-2019, Nigel Stewart <nigels[]users sourceforge net>
+** Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
 ** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
 ** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
 ** Copyright (C) 2002, Lev Povalahev
@@ -675,6 +675,17 @@ typedef void ( * PFNGLXRELEASETEXIMAGEATIPROC) (Display *dpy, GLXPbuffer pbuf, i
 
 #endif /* GLX_EXT_framebuffer_sRGB */
 
+/* ----------------------- GLX_EXT_get_drawable_type ----------------------- */
+
+#ifndef GLX_EXT_get_drawable_type
+#define GLX_EXT_get_drawable_type 1
+
+#define GLX_DRAWABLE_TYPE 0x8010
+
+#define GLXEW_EXT_get_drawable_type GLXEW_GET_VAR(__GLXEW_EXT_get_drawable_type)
+
+#endif /* GLX_EXT_get_drawable_type */
+
 /* ------------------------- GLX_EXT_import_context ------------------------ */
 
 #ifndef GLX_EXT_import_context
@@ -1760,6 +1771,7 @@ GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_create_context_es2_profile;
 GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_create_context_es_profile;
 GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_fbconfig_packed_float;
 GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_framebuffer_sRGB;
+GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_get_drawable_type;
 GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_import_context;
 GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_libglvnd;
 GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_no_config_context;
@@ -1811,7 +1823,7 @@ GLXEW_VAR_EXPORT GLboolean __GLXEW_SUN_get_transparent_index;
 GLXEW_VAR_EXPORT GLboolean __GLXEW_SUN_video_resize;
 /* ------------------------------------------------------------------------ */
 
-GLEWAPI GLenum GLEWAPIENTRY glxewInit ();
+GLEWAPI GLenum GLEWAPIENTRY glxewInit (void);
 GLEWAPI GLboolean GLEWAPIENTRY glxewIsSupported (const char *name);
 
 #ifndef GLXEW_GET_VAR
diff --git a/3rdparty/glew/include/GL/wglew.h b/3rdparty/glew/include/GL/wglew.h
index 7e2d0904cbd..c7733b05540 100644
--- a/3rdparty/glew/include/GL/wglew.h
+++ b/3rdparty/glew/include/GL/wglew.h
@@ -1,6 +1,6 @@
 /*
 ** The OpenGL Extension Wrangler Library
-** Copyright (C) 2008-2019, Nigel Stewart <nigels[]users sourceforge net>
+** Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
 ** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
 ** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
 ** Copyright (C) 2002, Lev Povalahev
@@ -1446,7 +1446,7 @@ WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_video_output;
 WGLEW_VAR_EXPORT GLboolean __WGLEW_OML_sync_control;
 /* ------------------------------------------------------------------------- */
 
-GLEWAPI GLenum GLEWAPIENTRY wglewInit ();
+GLEWAPI GLenum GLEWAPIENTRY wglewInit (void);
 GLEWAPI GLboolean GLEWAPIENTRY wglewIsSupported (const char *name);
 
 #ifndef WGLEW_GET_VAR
diff --git a/3rdparty/glew/src/glew.c b/3rdparty/glew/src/glew.c
index 967c5c91f95..56b8aacfaf0 100644
--- a/3rdparty/glew/src/glew.c
+++ b/3rdparty/glew/src/glew.c
@@ -1,6 +1,6 @@
 /*
 ** The OpenGL Extension Wrangler Library
-** Copyright (C) 2008-2019, Nigel Stewart <nigels[]users sourceforge net>
+** Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
 ** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
 ** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
 ** Copyright (C) 2002, Lev Povalahev
@@ -38,7 +38,15 @@
 
 #if defined(GLEW_OSMESA)
 #  define GLAPI extern
+#  ifndef APIENTRY
+#    define APIENTRY
+#    define GLEW_APIENTRY_DEFINED
+#  endif
 #  include <GL/osmesa.h>
+#  ifdef GLEW_APIENTRY_DEFINED
+#    undef APIENTRY
+#    undef GLEW_APIENTRY_DEFINED
+#  endif
 #elif defined(GLEW_EGL)
 #  include <GL/eglew.h>
 #elif defined(_WIN32)
@@ -60,7 +68,7 @@
 #if defined(GLEW_EGL)
 #elif defined(GLEW_REGAL)
 
-/* In GLEW_REGAL mode we call direcly into the linked
+/* In GLEW_REGAL mode we call directly into the linked
    libRegal.so glGetProcAddressREGAL for looking up
    the GL function pointers. */
 
@@ -102,7 +110,7 @@ void* dlGetProcAddress (const GLubyte* name)
 #include <string.h>
 #include <AvailabilityMacros.h>
 
-#ifdef MAC_OS_X_VERSION_10_3
+#if defined(MAC_OS_X_VERSION_10_3) && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3
 
 #include <dlfcn.h>
 
@@ -152,7 +160,7 @@ void* NSGLGetProcAddress (const GLubyte *name)
   return NULL;
 #endif
 }
-#endif /* MAC_OS_X_VERSION_10_3 */
+#endif /* defined(MAC_OS_X_VERSION_10_3) && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3 */
 #endif /* __APPLE__ */
 
 /*
@@ -253,7 +261,7 @@ static GLboolean _glewStrSame1 (const GLubyte** a, GLuint* na, const GLubyte* b,
   if(*na >= nb)
   {
     GLuint i=0;
-    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
+    while (i < nb && (*a)[i] == b[i]) i++;
     if(i == nb)
     {
       *a = *a + nb;
@@ -269,7 +277,7 @@ static GLboolean _glewStrSame2 (const GLubyte** a, GLuint* na, const GLubyte* b,
   if(*na >= nb)
   {
     GLuint i=0;
-    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
+    while (i < nb && (*a)[i] == b[i]) i++;
     if(i == nb)
     {
       *a = *a + nb;
@@ -285,7 +293,7 @@ static GLboolean _glewStrSame3 (const GLubyte** a, GLuint* na, const GLubyte* b,
   if(*na >= nb)
   {
     GLuint i=0;
-    while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
+    while (i < nb && (*a)[i] == b[i]) i++;
     if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t'))
     {
       *a = *a + nb;
@@ -1179,6 +1187,7 @@ PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL;
 PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL;
 PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL;
 
+PFNGLEVALUATEDEPTHVALUESARBPROC __glewEvaluateDepthValuesARB = NULL;
 PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewFramebufferSampleLocationsfvARB = NULL;
 PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewNamedFramebufferSampleLocationsfvARB = NULL;
 
@@ -1591,6 +1600,8 @@ PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;
 PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;
 PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;
 
+PFNGLMAXACTIVESHADERCORESARMPROC __glewMaxActiveShaderCoresARM = NULL;
+
 PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;
 
 PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;
@@ -1713,7 +1724,6 @@ PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;
 PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;
 
 PFNGLBUFFERSTORAGEEXTPROC __glewBufferStorageEXT = NULL;
-PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL;
 
 PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT = NULL;
 PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT = NULL;
@@ -1892,6 +1902,7 @@ PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL;
 PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL;
 PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL;
 PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL;
+PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL;
 PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL;
 PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL;
 PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL;
@@ -1954,6 +1965,7 @@ PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL;
 PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL;
 PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL;
 PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL;
+PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL;
 PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL;
 PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL;
 PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL;
@@ -2050,8 +2062,16 @@ PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;
 PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;
 PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;
 
+PFNGLFRAMEBUFFERSHADINGRATEEXTPROC __glewFramebufferShadingRateEXT = NULL;
+PFNGLGETFRAGMENTSHADINGRATESEXTPROC __glewGetFragmentShadingRatesEXT = NULL;
+PFNGLSHADINGRATECOMBINEROPSEXTPROC __glewShadingRateCombinerOpsEXT = NULL;
+PFNGLSHADINGRATEEXTPROC __glewShadingRateEXT = NULL;
+
 PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL;
 
+PFNGLBLITFRAMEBUFFERLAYEREXTPROC __glewBlitFramebufferLayerEXT = NULL;
+PFNGLBLITFRAMEBUFFERLAYERSEXTPROC __glewBlitFramebufferLayersEXT = NULL;
+
 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL;
 
 PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;
@@ -2163,6 +2183,11 @@ PFNGLIMPORTMEMORYFDEXTPROC __glewImportMemoryFdEXT = NULL;
 PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC __glewImportMemoryWin32HandleEXT = NULL;
 PFNGLIMPORTMEMORYWIN32NAMEEXTPROC __glewImportMemoryWin32NameEXT = NULL;
 
+PFNGLDRAWMESHTASKSEXTPROC __glewDrawMeshTasksEXT = NULL;
+PFNGLDRAWMESHTASKSINDIRECTEXTPROC __glewDrawMeshTasksIndirectEXT = NULL;
+PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC __glewMultiDrawMeshTasksIndirectCountEXT = NULL;
+PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC __glewMultiDrawMeshTasksIndirectEXT = NULL;
+
 PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;
 PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;
 
@@ -2206,6 +2231,7 @@ PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTableNV = NULL;
 PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV = NULL;
 PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT = NULL;
 
+PFNGLGETGRAPHICSRESETSTATUSEXTPROC __glewGetGraphicsResetStatusEXT = NULL;
 PFNGLGETNUNIFORMFVEXTPROC __glewGetnUniformfvEXT = NULL;
 PFNGLGETNUNIFORMIVEXTPROC __glewGetnUniformivEXT = NULL;
 PFNGLREADNPIXELSEXTPROC __glewReadnPixelsEXT = NULL;
@@ -2258,7 +2284,6 @@ PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewFramebufferPixelLocalStorageS
 PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewGetFramebufferPixelLocalStorageSizeEXT = NULL;
 
 PFNGLTEXPAGECOMMITMENTEXTPROC __glewTexPageCommitmentEXT = NULL;
-PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL;
 
 PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;
 
@@ -2302,6 +2327,9 @@ PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL;
 PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL;
 PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL;
 
+PFNGLTEXSTORAGEATTRIBS2DEXTPROC __glewTexStorageAttribs2DEXT = NULL;
+PFNGLTEXSTORAGEATTRIBS3DEXTPROC __glewTexStorageAttribs3DEXT = NULL;
+
 PFNGLTEXTUREVIEWEXTPROC __glewTextureViewEXT = NULL;
 
 PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL;
@@ -2430,6 +2458,8 @@ PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC __glewFramebufferTextureLayerDowns
 PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC __glewFramebufferTexture2DMultisampleIMG = NULL;
 PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC __glewRenderbufferStorageMultisampleIMG = NULL;
 
+PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC __glewApplyFramebufferAttachmentCMAAINTEL = NULL;
+
 PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL = NULL;
 PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL = NULL;
 PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL = NULL;
@@ -2524,6 +2554,7 @@ PFNGLLGPUINTERLOCKNVXPROC __glewLGPUInterlockNVX = NULL;
 PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC __glewLGPUNamedBufferSubDataNVX = NULL;
 
 PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC __glewClientWaitSemaphoreui64NVX = NULL;
+PFNGLCREATEPROGRESSFENCENVXPROC __glewCreateProgressFenceNVX = NULL;
 PFNGLSIGNALSEMAPHOREUI64NVXPROC __glewSignalSemaphoreui64NVX = NULL;
 PFNGLWAITSEMAPHOREUI64NVXPROC __glewWaitSemaphoreui64NVX = NULL;
 
@@ -2763,6 +2794,11 @@ PFNGLRESETMEMORYOBJECTPARAMETERNVPROC __glewResetMemoryObjectParameterNV = NULL;
 PFNGLTEXATTACHMEMORYNVPROC __glewTexAttachMemoryNV = NULL;
 PFNGLTEXTUREATTACHMEMORYNVPROC __glewTextureAttachMemoryNV = NULL;
 
+PFNGLBUFFERPAGECOMMITMENTMEMNVPROC __glewBufferPageCommitmentMemNV = NULL;
+PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC __glewNamedBufferPageCommitmentMemNV = NULL;
+PFNGLTEXPAGECOMMITMENTMEMNVPROC __glewTexPageCommitmentMemNV = NULL;
+PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC __glewTexturePageCommitmentMemNV = NULL;
+
 PFNGLDRAWMESHTASKSINDIRECTNVPROC __glewDrawMeshTasksIndirectNV = NULL;
 PFNGLDRAWMESHTASKSNVPROC __glewDrawMeshTasksNV = NULL;
 PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC __glewMultiDrawMeshTasksIndirectCountNV = NULL;
@@ -2916,6 +2952,7 @@ PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC __glewGetShadingRateSampleLocationivNV
 PFNGLSHADINGRATEIMAGEBARRIERNVPROC __glewShadingRateImageBarrierNV = NULL;
 PFNGLSHADINGRATEIMAGEPALETTENVPROC __glewShadingRateImagePaletteNV = NULL;
 PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC __glewShadingRateSampleOrderCustomNV = NULL;
+PFNGLSHADINGRATESAMPLEORDERNVPROC __glewShadingRateSampleOrderNV = NULL;
 
 PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV = NULL;
 PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV = NULL;
@@ -2933,6 +2970,10 @@ PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL;
 PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL;
 PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL;
 
+PFNGLCREATESEMAPHORESNVPROC __glewCreateSemaphoresNV = NULL;
+PFNGLGETSEMAPHOREPARAMETERIVNVPROC __glewGetSemaphoreParameterivNV = NULL;
+PFNGLSEMAPHOREPARAMETERIVNVPROC __glewSemaphoreParameterivNV = NULL;
+
 PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;
 PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;
 PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;
@@ -3139,6 +3180,7 @@ PFNGLMAPBUFFEROESPROC __glewMapBufferOES = NULL;
 PFNGLUNMAPBUFFEROESPROC __glewUnmapBufferOES = NULL;
 
 PFNGLCURRENTPALETTEMATRIXOESPROC __glewCurrentPaletteMatrixOES = NULL;
+PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC __glewLoadPaletteFromModelViewMatrixOES = NULL;
 PFNGLMATRIXINDEXPOINTEROESPROC __glewMatrixIndexPointerOES = NULL;
 PFNGLWEIGHTPOINTEROESPROC __glewWeightPointerOES = NULL;
 
@@ -3215,11 +3257,18 @@ PFNGLEXTGETPROGRAMSQCOMPROC __glewExtGetProgramsQCOM = NULL;
 PFNGLEXTGETSHADERSQCOMPROC __glewExtGetShadersQCOM = NULL;
 PFNGLEXTISPROGRAMBINARYQCOMPROC __glewExtIsProgramBinaryQCOM = NULL;
 
+PFNGLEXTRAPOLATETEX2DQCOMPROC __glewExtrapolateTex2DQCOM = NULL;
+
 PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC __glewFramebufferFoveationConfigQCOM = NULL;
 PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParametersQCOM = NULL;
 
+PFNGLTEXESTIMATEMOTIONQCOMPROC __glewTexEstimateMotionQCOM = NULL;
+PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC __glewTexEstimateMotionRegionsQCOM = NULL;
+
 PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM = NULL;
 
+PFNGLSHADINGRATEQCOMPROC __glewShadingRateQCOM = NULL;
+
 PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC __glewTextureFoveationParametersQCOM = NULL;
 
 PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM = NULL;
@@ -3744,6 +3793,7 @@ GLboolean __GLEW_ARB_window_pos = GL_FALSE;
 GLboolean __GLEW_ARM_mali_program_binary = GL_FALSE;
 GLboolean __GLEW_ARM_mali_shader_binary = GL_FALSE;
 GLboolean __GLEW_ARM_rgba8 = GL_FALSE;
+GLboolean __GLEW_ARM_shader_core_properties = GL_FALSE;
 GLboolean __GLEW_ARM_shader_framebuffer_fetch = GL_FALSE;
 GLboolean __GLEW_ARM_shader_framebuffer_fetch_depth_stencil = GL_FALSE;
 GLboolean __GLEW_ARM_texture_unnormalized_coordinates = GL_FALSE;
@@ -3775,6 +3825,7 @@ GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;
 GLboolean __GLEW_EXT_EGL_image_array = GL_FALSE;
 GLboolean __GLEW_EXT_EGL_image_external_wrap_modes = GL_FALSE;
 GLboolean __GLEW_EXT_EGL_image_storage = GL_FALSE;
+GLboolean __GLEW_EXT_EGL_image_storage_compression = GL_FALSE;
 GLboolean __GLEW_EXT_EGL_sync = GL_FALSE;
 GLboolean __GLEW_EXT_YUV_target = GL_FALSE;
 GLboolean __GLEW_EXT_abgr = GL_FALSE;
@@ -3824,7 +3875,11 @@ GLboolean __GLEW_EXT_float_blend = GL_FALSE;
 GLboolean __GLEW_EXT_fog_coord = GL_FALSE;
 GLboolean __GLEW_EXT_frag_depth = GL_FALSE;
 GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;
+GLboolean __GLEW_EXT_fragment_shading_rate = GL_FALSE;
+GLboolean __GLEW_EXT_fragment_shading_rate_attachment = GL_FALSE;
+GLboolean __GLEW_EXT_fragment_shading_rate_primitive = GL_FALSE;
 GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE;
+GLboolean __GLEW_EXT_framebuffer_blit_layers = GL_FALSE;
 GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE;
 GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE;
 GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;
@@ -3846,6 +3901,7 @@ GLboolean __GLEW_EXT_map_buffer_range = GL_FALSE;
 GLboolean __GLEW_EXT_memory_object = GL_FALSE;
 GLboolean __GLEW_EXT_memory_object_fd = GL_FALSE;
 GLboolean __GLEW_EXT_memory_object_win32 = GL_FALSE;
+GLboolean __GLEW_EXT_mesh_shader = GL_FALSE;
 GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;
 GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;
 GLboolean __GLEW_EXT_multi_draw_indirect = GL_FALSE;
@@ -3886,8 +3942,10 @@ GLboolean __GLEW_EXT_secondary_color = GL_FALSE;
 GLboolean __GLEW_EXT_semaphore = GL_FALSE;
 GLboolean __GLEW_EXT_semaphore_fd = GL_FALSE;
 GLboolean __GLEW_EXT_semaphore_win32 = GL_FALSE;
+GLboolean __GLEW_EXT_separate_depth_stencil = GL_FALSE;
 GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE;
 GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;
+GLboolean __GLEW_EXT_shader_clock = GL_FALSE;
 GLboolean __GLEW_EXT_shader_framebuffer_fetch = GL_FALSE;
 GLboolean __GLEW_EXT_shader_framebuffer_fetch_non_coherent = GL_FALSE;
 GLboolean __GLEW_EXT_shader_group_vote = GL_FALSE;
@@ -3899,7 +3957,10 @@ GLboolean __GLEW_EXT_shader_io_blocks = GL_FALSE;
 GLboolean __GLEW_EXT_shader_non_constant_global_initializers = GL_FALSE;
 GLboolean __GLEW_EXT_shader_pixel_local_storage = GL_FALSE;
 GLboolean __GLEW_EXT_shader_pixel_local_storage2 = GL_FALSE;
+GLboolean __GLEW_EXT_shader_realtime_clock = GL_FALSE;
+GLboolean __GLEW_EXT_shader_samples_identical = GL_FALSE;
 GLboolean __GLEW_EXT_shader_texture_lod = GL_FALSE;
+GLboolean __GLEW_EXT_shader_texture_samples = GL_FALSE;
 GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;
 GLboolean __GLEW_EXT_shadow_samplers = GL_FALSE;
 GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;
@@ -3955,6 +4016,7 @@ GLboolean __GLEW_EXT_texture_shadow_lod = GL_FALSE;
 GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;
 GLboolean __GLEW_EXT_texture_snorm = GL_FALSE;
 GLboolean __GLEW_EXT_texture_storage = GL_FALSE;
+GLboolean __GLEW_EXT_texture_storage_compression = GL_FALSE;
 GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE;
 GLboolean __GLEW_EXT_texture_type_2_10_10_10_REV = GL_FALSE;
 GLboolean __GLEW_EXT_texture_view = GL_FALSE;
@@ -3977,6 +4039,8 @@ GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;
 GLboolean __GLEW_HP_image_transform = GL_FALSE;
 GLboolean __GLEW_HP_occlusion_test = GL_FALSE;
 GLboolean __GLEW_HP_texture_lighting = GL_FALSE;
+GLboolean __GLEW_HUAWEI_program_binary = GL_FALSE;
+GLboolean __GLEW_HUAWEI_shader_binary = GL_FALSE;
 GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;
 GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;
 GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;
@@ -3987,12 +4051,14 @@ GLboolean __GLEW_IMG_bindless_texture = GL_FALSE;
 GLboolean __GLEW_IMG_framebuffer_downsample = GL_FALSE;
 GLboolean __GLEW_IMG_multisampled_render_to_texture = GL_FALSE;
 GLboolean __GLEW_IMG_program_binary = GL_FALSE;
+GLboolean __GLEW_IMG_pvric_end_to_end_signature = GL_FALSE;
 GLboolean __GLEW_IMG_read_format = GL_FALSE;
 GLboolean __GLEW_IMG_shader_binary = GL_FALSE;
 GLboolean __GLEW_IMG_texture_compression_pvrtc = GL_FALSE;
 GLboolean __GLEW_IMG_texture_compression_pvrtc2 = GL_FALSE;
 GLboolean __GLEW_IMG_texture_env_enhanced_fixed_function = GL_FALSE;
 GLboolean __GLEW_IMG_texture_filter_cubic = GL_FALSE;
+GLboolean __GLEW_IMG_tile_region_protection = GL_FALSE;
 GLboolean __GLEW_INGR_color_clamp = GL_FALSE;
 GLboolean __GLEW_INGR_interlace_read = GL_FALSE;
 GLboolean __GLEW_INTEL_blackhole_render = GL_FALSE;
@@ -4018,11 +4084,15 @@ GLboolean __GLEW_KHR_texture_compression_astc_ldr = GL_FALSE;
 GLboolean __GLEW_KHR_texture_compression_astc_sliced_3d = GL_FALSE;
 GLboolean __GLEW_KTX_buffer_region = GL_FALSE;
 GLboolean __GLEW_MESAX_texture_stack = GL_FALSE;
+GLboolean __GLEW_MESA_bgra = GL_FALSE;
+GLboolean __GLEW_MESA_framebuffer_flip_x = GL_FALSE;
 GLboolean __GLEW_MESA_framebuffer_flip_y = GL_FALSE;
+GLboolean __GLEW_MESA_framebuffer_swap_xy = GL_FALSE;
 GLboolean __GLEW_MESA_pack_invert = GL_FALSE;
 GLboolean __GLEW_MESA_program_binary_formats = GL_FALSE;
 GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;
 GLboolean __GLEW_MESA_shader_integer_functions = GL_FALSE;
+GLboolean __GLEW_MESA_texture_const_bandwidth = GL_FALSE;
 GLboolean __GLEW_MESA_tile_raster_order = GL_FALSE;
 GLboolean __GLEW_MESA_window_pos = GL_FALSE;
 GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;
@@ -4100,6 +4170,7 @@ GLboolean __GLEW_NV_instanced_arrays = GL_FALSE;
 GLboolean __GLEW_NV_internalformat_sample_query = GL_FALSE;
 GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;
 GLboolean __GLEW_NV_memory_attachment = GL_FALSE;
+GLboolean __GLEW_NV_memory_object_sparse = GL_FALSE;
 GLboolean __GLEW_NV_mesh_shader = GL_FALSE;
 GLboolean __GLEW_NV_multisample_coverage = GL_FALSE;
 GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;
@@ -4120,6 +4191,7 @@ GLboolean __GLEW_NV_point_sprite = GL_FALSE;
 GLboolean __GLEW_NV_polygon_mode = GL_FALSE;
 GLboolean __GLEW_NV_present_video = GL_FALSE;
 GLboolean __GLEW_NV_primitive_restart = GL_FALSE;
+GLboolean __GLEW_NV_primitive_shading_rate = GL_FALSE;
 GLboolean __GLEW_NV_query_resource_tag = GL_FALSE;
 GLboolean __GLEW_NV_read_buffer = GL_FALSE;
 GLboolean __GLEW_NV_read_buffer_front = GL_FALSE;
@@ -4169,8 +4241,10 @@ GLboolean __GLEW_NV_texture_rectangle_compressed = GL_FALSE;
 GLboolean __GLEW_NV_texture_shader = GL_FALSE;
 GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;
 GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;
+GLboolean __GLEW_NV_timeline_semaphore = GL_FALSE;
 GLboolean __GLEW_NV_transform_feedback = GL_FALSE;
 GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE;
+GLboolean __GLEW_NV_uniform_buffer_std430_layout = GL_FALSE;
 GLboolean __GLEW_NV_uniform_buffer_unified_memory = GL_FALSE;
 GLboolean __GLEW_NV_vdpau_interop = GL_FALSE;
 GLboolean __GLEW_NV_vdpau_interop2 = GL_FALSE;
@@ -4264,14 +4338,22 @@ GLboolean __GLEW_QCOM_binning_control = GL_FALSE;
 GLboolean __GLEW_QCOM_driver_control = GL_FALSE;
 GLboolean __GLEW_QCOM_extended_get = GL_FALSE;
 GLboolean __GLEW_QCOM_extended_get2 = GL_FALSE;
+GLboolean __GLEW_QCOM_frame_extrapolation = GL_FALSE;
 GLboolean __GLEW_QCOM_framebuffer_foveated = GL_FALSE;
+GLboolean __GLEW_QCOM_motion_estimation = GL_FALSE;
 GLboolean __GLEW_QCOM_perfmon_global_mode = GL_FALSE;
+GLboolean __GLEW_QCOM_render_sRGB_R8_RG8 = GL_FALSE;
+GLboolean __GLEW_QCOM_render_shared_exponent = GL_FALSE;
 GLboolean __GLEW_QCOM_shader_framebuffer_fetch_noncoherent = GL_FALSE;
 GLboolean __GLEW_QCOM_shader_framebuffer_fetch_rate = GL_FALSE;
+GLboolean __GLEW_QCOM_shading_rate = GL_FALSE;
 GLboolean __GLEW_QCOM_texture_foveated = GL_FALSE;
+GLboolean __GLEW_QCOM_texture_foveated2 = GL_FALSE;
 GLboolean __GLEW_QCOM_texture_foveated_subsampled_layout = GL_FALSE;
+GLboolean __GLEW_QCOM_texture_lod_bias = GL_FALSE;
 GLboolean __GLEW_QCOM_tiled_rendering = GL_FALSE;
 GLboolean __GLEW_QCOM_writeonly_rendering = GL_FALSE;
+GLboolean __GLEW_QCOM_ycbcr_degamma = GL_FALSE;
 GLboolean __GLEW_REGAL_ES1_0_compatibility = GL_FALSE;
 GLboolean __GLEW_REGAL_ES1_1_compatibility = GL_FALSE;
 GLboolean __GLEW_REGAL_enable = GL_FALSE;
@@ -5173,6 +5255,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_ARM_rgba8
   "GL_ARM_rgba8",
 #endif
+#ifdef GL_ARM_shader_core_properties
+  "GL_ARM_shader_core_properties",
+#endif
 #ifdef GL_ARM_shader_framebuffer_fetch
   "GL_ARM_shader_framebuffer_fetch",
 #endif
@@ -5266,6 +5351,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_EXT_EGL_image_storage
   "GL_EXT_EGL_image_storage",
 #endif
+#ifdef GL_EXT_EGL_image_storage_compression
+  "GL_EXT_EGL_image_storage_compression",
+#endif
 #ifdef GL_EXT_EGL_sync
   "GL_EXT_EGL_sync",
 #endif
@@ -5413,9 +5501,21 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_EXT_fragment_lighting
   "GL_EXT_fragment_lighting",
 #endif
+#ifdef GL_EXT_fragment_shading_rate
+  "GL_EXT_fragment_shading_rate",
+#endif
+#ifdef GL_EXT_fragment_shading_rate_attachment
+  "GL_EXT_fragment_shading_rate_attachment",
+#endif
+#ifdef GL_EXT_fragment_shading_rate_primitive
+  "GL_EXT_fragment_shading_rate_primitive",
+#endif
 #ifdef GL_EXT_framebuffer_blit
   "GL_EXT_framebuffer_blit",
 #endif
+#ifdef GL_EXT_framebuffer_blit_layers
+  "GL_EXT_framebuffer_blit_layers",
+#endif
 #ifdef GL_EXT_framebuffer_multisample
   "GL_EXT_framebuffer_multisample",
 #endif
@@ -5479,6 +5579,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_EXT_memory_object_win32
   "GL_EXT_memory_object_win32",
 #endif
+#ifdef GL_EXT_mesh_shader
+  "GL_EXT_mesh_shader",
+#endif
 #ifdef GL_EXT_misc_attribute
   "GL_EXT_misc_attribute",
 #endif
@@ -5599,12 +5702,18 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_EXT_semaphore_win32
   "GL_EXT_semaphore_win32",
 #endif
+#ifdef GL_EXT_separate_depth_stencil
+  "GL_EXT_separate_depth_stencil",
+#endif
 #ifdef GL_EXT_separate_shader_objects
   "GL_EXT_separate_shader_objects",
 #endif
 #ifdef GL_EXT_separate_specular_color
   "GL_EXT_separate_specular_color",
 #endif
+#ifdef GL_EXT_shader_clock
+  "GL_EXT_shader_clock",
+#endif
 #ifdef GL_EXT_shader_framebuffer_fetch
   "GL_EXT_shader_framebuffer_fetch",
 #endif
@@ -5638,9 +5747,18 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_EXT_shader_pixel_local_storage2
   "GL_EXT_shader_pixel_local_storage2",
 #endif
+#ifdef GL_EXT_shader_realtime_clock
+  "GL_EXT_shader_realtime_clock",
+#endif
+#ifdef GL_EXT_shader_samples_identical
+  "GL_EXT_shader_samples_identical",
+#endif
 #ifdef GL_EXT_shader_texture_lod
   "GL_EXT_shader_texture_lod",
 #endif
+#ifdef GL_EXT_shader_texture_samples
+  "GL_EXT_shader_texture_samples",
+#endif
 #ifdef GL_EXT_shadow_funcs
   "GL_EXT_shadow_funcs",
 #endif
@@ -5806,6 +5924,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_EXT_texture_storage
   "GL_EXT_texture_storage",
 #endif
+#ifdef GL_EXT_texture_storage_compression
+  "GL_EXT_texture_storage_compression",
+#endif
 #ifdef GL_EXT_texture_swizzle
   "GL_EXT_texture_swizzle",
 #endif
@@ -5872,6 +5993,12 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_HP_texture_lighting
   "GL_HP_texture_lighting",
 #endif
+#ifdef GL_HUAWEI_program_binary
+  "GL_HUAWEI_program_binary",
+#endif
+#ifdef GL_HUAWEI_shader_binary
+  "GL_HUAWEI_shader_binary",
+#endif
 #ifdef GL_IBM_cull_vertex
   "GL_IBM_cull_vertex",
 #endif
@@ -5902,6 +6029,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_IMG_program_binary
   "GL_IMG_program_binary",
 #endif
+#ifdef GL_IMG_pvric_end_to_end_signature
+  "GL_IMG_pvric_end_to_end_signature",
+#endif
 #ifdef GL_IMG_read_format
   "GL_IMG_read_format",
 #endif
@@ -5920,6 +6050,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_IMG_texture_filter_cubic
   "GL_IMG_texture_filter_cubic",
 #endif
+#ifdef GL_IMG_tile_region_protection
+  "GL_IMG_tile_region_protection",
+#endif
 #ifdef GL_INGR_color_clamp
   "GL_INGR_color_clamp",
 #endif
@@ -5995,9 +6128,18 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_MESAX_texture_stack
   "GL_MESAX_texture_stack",
 #endif
+#ifdef GL_MESA_bgra
+  "GL_MESA_bgra",
+#endif
+#ifdef GL_MESA_framebuffer_flip_x
+  "GL_MESA_framebuffer_flip_x",
+#endif
 #ifdef GL_MESA_framebuffer_flip_y
   "GL_MESA_framebuffer_flip_y",
 #endif
+#ifdef GL_MESA_framebuffer_swap_xy
+  "GL_MESA_framebuffer_swap_xy",
+#endif
 #ifdef GL_MESA_pack_invert
   "GL_MESA_pack_invert",
 #endif
@@ -6010,6 +6152,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_MESA_shader_integer_functions
   "GL_MESA_shader_integer_functions",
 #endif
+#ifdef GL_MESA_texture_const_bandwidth
+  "GL_MESA_texture_const_bandwidth",
+#endif
 #ifdef GL_MESA_tile_raster_order
   "GL_MESA_tile_raster_order",
 #endif
@@ -6241,6 +6386,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_NV_memory_attachment
   "GL_NV_memory_attachment",
 #endif
+#ifdef GL_NV_memory_object_sparse
+  "GL_NV_memory_object_sparse",
+#endif
 #ifdef GL_NV_mesh_shader
   "GL_NV_mesh_shader",
 #endif
@@ -6301,6 +6449,9 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_NV_primitive_restart
   "GL_NV_primitive_restart",
 #endif
+#ifdef GL_NV_primitive_shading_rate
+  "GL_NV_primitive_shading_rate",
+#endif
 #ifdef GL_NV_query_resource_tag
   "GL_NV_query_resource_tag",
 #endif
@@ -6448,12 +6599,18 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_NV_texture_shader3
   "GL_NV_texture_shader3",
 #endif
+#ifdef GL_NV_timeline_semaphore
+  "GL_NV_timeline_semaphore",
+#endif
 #ifdef GL_NV_transform_feedback
   "GL_NV_transform_feedback",
 #endif
 #ifdef GL_NV_transform_feedback2
   "GL_NV_transform_feedback2",
 #endif
+#ifdef GL_NV_uniform_buffer_std430_layout
+  "GL_NV_uniform_buffer_std430_layout",
+#endif
 #ifdef GL_NV_uniform_buffer_unified_memory
   "GL_NV_uniform_buffer_unified_memory",
 #endif
@@ -6733,30 +6890,54 @@ static const char * _glewExtensionLookup[] = {
 #ifdef GL_QCOM_extended_get2
   "GL_QCOM_extended_get2",
 #endif
+#ifdef GL_QCOM_frame_extrapolation
+  "GL_QCOM_frame_extrapolation",
+#endif
 #ifdef GL_QCOM_framebuffer_foveated
   "GL_QCOM_framebuffer_foveated",
 #endif
+#ifdef GL_QCOM_motion_estimation
+  "GL_QCOM_motion_estimation",
+#endif
 #ifdef GL_QCOM_perfmon_global_mode
   "GL_QCOM_perfmon_global_mode",
 #endif
+#ifdef GL_QCOM_render_sRGB_R8_RG8
+  "GL_QCOM_render_sRGB_R8_RG8",
+#endif
+#ifdef GL_QCOM_render_shared_exponent
+  "GL_QCOM_render_shared_exponent",
+#endif
 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent
   "GL_QCOM_shader_framebuffer_fetch_noncoherent",
 #endif
 #ifdef GL_QCOM_shader_framebuffer_fetch_rate
   "GL_QCOM_shader_framebuffer_fetch_rate",
 #endif
+#ifdef GL_QCOM_shading_rate
+  "GL_QCOM_shading_rate",
+#endif
 #ifdef GL_QCOM_texture_foveated
   "GL_QCOM_texture_foveated",
 #endif
+#ifdef GL_QCOM_texture_foveated2
+  "GL_QCOM_texture_foveated2",
+#endif
 #ifdef GL_QCOM_texture_foveated_subsampled_layout
   "GL_QCOM_texture_foveated_subsampled_layout",
 #endif
+#ifdef GL_QCOM_texture_lod_bias
+  "GL_QCOM_texture_lod_bias",
+#endif
 #ifdef GL_QCOM_tiled_rendering
   "GL_QCOM_tiled_rendering",
 #endif
 #ifdef GL_QCOM_writeonly_rendering
   "GL_QCOM_writeonly_rendering",
 #endif
+#ifdef GL_QCOM_ycbcr_degamma
+  "GL_QCOM_ycbcr_degamma",
+#endif
 #ifdef GL_REGAL_ES1_0_compatibility
   "GL_REGAL_ES1_0_compatibility",
 #endif
@@ -7200,7 +7381,7 @@ static const char * _glewExtensionLookup[] = {
 
 
 /* Detected in the extension string or strings */
-static GLboolean  _glewExtensionString[931];
+static GLboolean  _glewExtensionString[964];
 /* Detected via extension string or experimental mode */
 static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_3DFX_multisample
@@ -7974,6 +8155,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_ARM_rgba8
   &__GLEW_ARM_rgba8,
 #endif
+#ifdef GL_ARM_shader_core_properties
+  &__GLEW_ARM_shader_core_properties,
+#endif
 #ifdef GL_ARM_shader_framebuffer_fetch
   &__GLEW_ARM_shader_framebuffer_fetch,
 #endif
@@ -8067,6 +8251,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_EXT_EGL_image_storage
   &__GLEW_EXT_EGL_image_storage,
 #endif
+#ifdef GL_EXT_EGL_image_storage_compression
+  &__GLEW_EXT_EGL_image_storage_compression,
+#endif
 #ifdef GL_EXT_EGL_sync
   &__GLEW_EXT_EGL_sync,
 #endif
@@ -8214,9 +8401,21 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_EXT_fragment_lighting
   &__GLEW_EXT_fragment_lighting,
 #endif
+#ifdef GL_EXT_fragment_shading_rate
+  &__GLEW_EXT_fragment_shading_rate,
+#endif
+#ifdef GL_EXT_fragment_shading_rate_attachment
+  &__GLEW_EXT_fragment_shading_rate_attachment,
+#endif
+#ifdef GL_EXT_fragment_shading_rate_primitive
+  &__GLEW_EXT_fragment_shading_rate_primitive,
+#endif
 #ifdef GL_EXT_framebuffer_blit
   &__GLEW_EXT_framebuffer_blit,
 #endif
+#ifdef GL_EXT_framebuffer_blit_layers
+  &__GLEW_EXT_framebuffer_blit_layers,
+#endif
 #ifdef GL_EXT_framebuffer_multisample
   &__GLEW_EXT_framebuffer_multisample,
 #endif
@@ -8280,6 +8479,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_EXT_memory_object_win32
   &__GLEW_EXT_memory_object_win32,
 #endif
+#ifdef GL_EXT_mesh_shader
+  &__GLEW_EXT_mesh_shader,
+#endif
 #ifdef GL_EXT_misc_attribute
   &__GLEW_EXT_misc_attribute,
 #endif
@@ -8400,12 +8602,18 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_EXT_semaphore_win32
   &__GLEW_EXT_semaphore_win32,
 #endif
+#ifdef GL_EXT_separate_depth_stencil
+  &__GLEW_EXT_separate_depth_stencil,
+#endif
 #ifdef GL_EXT_separate_shader_objects
   &__GLEW_EXT_separate_shader_objects,
 #endif
 #ifdef GL_EXT_separate_specular_color
   &__GLEW_EXT_separate_specular_color,
 #endif
+#ifdef GL_EXT_shader_clock
+  &__GLEW_EXT_shader_clock,
+#endif
 #ifdef GL_EXT_shader_framebuffer_fetch
   &__GLEW_EXT_shader_framebuffer_fetch,
 #endif
@@ -8439,9 +8647,18 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_EXT_shader_pixel_local_storage2
   &__GLEW_EXT_shader_pixel_local_storage2,
 #endif
+#ifdef GL_EXT_shader_realtime_clock
+  &__GLEW_EXT_shader_realtime_clock,
+#endif
+#ifdef GL_EXT_shader_samples_identical
+  &__GLEW_EXT_shader_samples_identical,
+#endif
 #ifdef GL_EXT_shader_texture_lod
   &__GLEW_EXT_shader_texture_lod,
 #endif
+#ifdef GL_EXT_shader_texture_samples
+  &__GLEW_EXT_shader_texture_samples,
+#endif
 #ifdef GL_EXT_shadow_funcs
   &__GLEW_EXT_shadow_funcs,
 #endif
@@ -8607,6 +8824,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_EXT_texture_storage
   &__GLEW_EXT_texture_storage,
 #endif
+#ifdef GL_EXT_texture_storage_compression
+  &__GLEW_EXT_texture_storage_compression,
+#endif
 #ifdef GL_EXT_texture_swizzle
   &__GLEW_EXT_texture_swizzle,
 #endif
@@ -8673,6 +8893,12 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_HP_texture_lighting
   &__GLEW_HP_texture_lighting,
 #endif
+#ifdef GL_HUAWEI_program_binary
+  &__GLEW_HUAWEI_program_binary,
+#endif
+#ifdef GL_HUAWEI_shader_binary
+  &__GLEW_HUAWEI_shader_binary,
+#endif
 #ifdef GL_IBM_cull_vertex
   &__GLEW_IBM_cull_vertex,
 #endif
@@ -8703,6 +8929,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_IMG_program_binary
   &__GLEW_IMG_program_binary,
 #endif
+#ifdef GL_IMG_pvric_end_to_end_signature
+  &__GLEW_IMG_pvric_end_to_end_signature,
+#endif
 #ifdef GL_IMG_read_format
   &__GLEW_IMG_read_format,
 #endif
@@ -8721,6 +8950,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_IMG_texture_filter_cubic
   &__GLEW_IMG_texture_filter_cubic,
 #endif
+#ifdef GL_IMG_tile_region_protection
+  &__GLEW_IMG_tile_region_protection,
+#endif
 #ifdef GL_INGR_color_clamp
   &__GLEW_INGR_color_clamp,
 #endif
@@ -8796,9 +9028,18 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_MESAX_texture_stack
   &__GLEW_MESAX_texture_stack,
 #endif
+#ifdef GL_MESA_bgra
+  &__GLEW_MESA_bgra,
+#endif
+#ifdef GL_MESA_framebuffer_flip_x
+  &__GLEW_MESA_framebuffer_flip_x,
+#endif
 #ifdef GL_MESA_framebuffer_flip_y
   &__GLEW_MESA_framebuffer_flip_y,
 #endif
+#ifdef GL_MESA_framebuffer_swap_xy
+  &__GLEW_MESA_framebuffer_swap_xy,
+#endif
 #ifdef GL_MESA_pack_invert
   &__GLEW_MESA_pack_invert,
 #endif
@@ -8811,6 +9052,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_MESA_shader_integer_functions
   &__GLEW_MESA_shader_integer_functions,
 #endif
+#ifdef GL_MESA_texture_const_bandwidth
+  &__GLEW_MESA_texture_const_bandwidth,
+#endif
 #ifdef GL_MESA_tile_raster_order
   &__GLEW_MESA_tile_raster_order,
 #endif
@@ -9042,6 +9286,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_NV_memory_attachment
   &__GLEW_NV_memory_attachment,
 #endif
+#ifdef GL_NV_memory_object_sparse
+  &__GLEW_NV_memory_object_sparse,
+#endif
 #ifdef GL_NV_mesh_shader
   &__GLEW_NV_mesh_shader,
 #endif
@@ -9102,6 +9349,9 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_NV_primitive_restart
   &__GLEW_NV_primitive_restart,
 #endif
+#ifdef GL_NV_primitive_shading_rate
+  &__GLEW_NV_primitive_shading_rate,
+#endif
 #ifdef GL_NV_query_resource_tag
   &__GLEW_NV_query_resource_tag,
 #endif
@@ -9249,12 +9499,18 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_NV_texture_shader3
   &__GLEW_NV_texture_shader3,
 #endif
+#ifdef GL_NV_timeline_semaphore
+  &__GLEW_NV_timeline_semaphore,
+#endif
 #ifdef GL_NV_transform_feedback
   &__GLEW_NV_transform_feedback,
 #endif
 #ifdef GL_NV_transform_feedback2
   &__GLEW_NV_transform_feedback2,
 #endif
+#ifdef GL_NV_uniform_buffer_std430_layout
+  &__GLEW_NV_uniform_buffer_std430_layout,
+#endif
 #ifdef GL_NV_uniform_buffer_unified_memory
   &__GLEW_NV_uniform_buffer_unified_memory,
 #endif
@@ -9534,30 +9790,54 @@ static GLboolean* _glewExtensionEnabled[] = {
 #ifdef GL_QCOM_extended_get2
   &__GLEW_QCOM_extended_get2,
 #endif
+#ifdef GL_QCOM_frame_extrapolation
+  &__GLEW_QCOM_frame_extrapolation,
+#endif
 #ifdef GL_QCOM_framebuffer_foveated
   &__GLEW_QCOM_framebuffer_foveated,
 #endif
+#ifdef GL_QCOM_motion_estimation
+  &__GLEW_QCOM_motion_estimation,
+#endif
 #ifdef GL_QCOM_perfmon_global_mode
   &__GLEW_QCOM_perfmon_global_mode,
 #endif
+#ifdef GL_QCOM_render_sRGB_R8_RG8
+  &__GLEW_QCOM_render_sRGB_R8_RG8,
+#endif
+#ifdef GL_QCOM_render_shared_exponent
+  &__GLEW_QCOM_render_shared_exponent,
+#endif
 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent
   &__GLEW_QCOM_shader_framebuffer_fetch_noncoherent,
 #endif
 #ifdef GL_QCOM_shader_framebuffer_fetch_rate
   &__GLEW_QCOM_shader_framebuffer_fetch_rate,
 #endif
+#ifdef GL_QCOM_shading_rate
+  &__GLEW_QCOM_shading_rate,
+#endif
 #ifdef GL_QCOM_texture_foveated
   &__GLEW_QCOM_texture_foveated,
 #endif
+#ifdef GL_QCOM_texture_foveated2
+  &__GLEW_QCOM_texture_foveated2,
+#endif
 #ifdef GL_QCOM_texture_foveated_subsampled_layout
   &__GLEW_QCOM_texture_foveated_subsampled_layout,
 #endif
+#ifdef GL_QCOM_texture_lod_bias
+  &__GLEW_QCOM_texture_lod_bias,
+#endif
 #ifdef GL_QCOM_tiled_rendering
   &__GLEW_QCOM_tiled_rendering,
 #endif
 #ifdef GL_QCOM_writeonly_rendering
   &__GLEW_QCOM_writeonly_rendering,
 #endif
+#ifdef GL_QCOM_ycbcr_degamma
+  &__GLEW_QCOM_ycbcr_degamma,
+#endif
 #ifdef GL_REGAL_ES1_0_compatibility
   &__GLEW_REGAL_ES1_0_compatibility,
 #endif
@@ -9999,404 +10279,415 @@ static GLboolean* _glewExtensionEnabled[] = {
   NULL
 };
 
-static GLboolean _glewInit_GL_VERSION_1_2 ();
-static GLboolean _glewInit_GL_VERSION_1_3 ();
-static GLboolean _glewInit_GL_VERSION_1_4 ();
-static GLboolean _glewInit_GL_VERSION_1_5 ();
-static GLboolean _glewInit_GL_VERSION_2_0 ();
-static GLboolean _glewInit_GL_VERSION_2_1 ();
-static GLboolean _glewInit_GL_VERSION_3_0 ();
-static GLboolean _glewInit_GL_VERSION_3_1 ();
-static GLboolean _glewInit_GL_VERSION_3_2 ();
-static GLboolean _glewInit_GL_VERSION_3_3 ();
-static GLboolean _glewInit_GL_VERSION_4_0 ();
-static GLboolean _glewInit_GL_VERSION_4_5 ();
-static GLboolean _glewInit_GL_VERSION_4_6 ();
-static GLboolean _glewInit_GL_3DFX_tbuffer ();
-static GLboolean _glewInit_GL_AMD_debug_output ();
-static GLboolean _glewInit_GL_AMD_draw_buffers_blend ();
-static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced ();
-static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions ();
-static GLboolean _glewInit_GL_AMD_interleaved_elements ();
-static GLboolean _glewInit_GL_AMD_multi_draw_indirect ();
-static GLboolean _glewInit_GL_AMD_name_gen_delete ();
-static GLboolean _glewInit_GL_AMD_occlusion_query_event ();
-static GLboolean _glewInit_GL_AMD_performance_monitor ();
-static GLboolean _glewInit_GL_AMD_sample_positions ();
-static GLboolean _glewInit_GL_AMD_sparse_texture ();
-static GLboolean _glewInit_GL_AMD_stencil_operation_extended ();
-static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator ();
-static GLboolean _glewInit_GL_ANGLE_framebuffer_blit ();
-static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample ();
-static GLboolean _glewInit_GL_ANGLE_instanced_arrays ();
-static GLboolean _glewInit_GL_ANGLE_timer_query ();
-static GLboolean _glewInit_GL_ANGLE_translated_shader_source ();
-static GLboolean _glewInit_GL_APPLE_copy_texture_levels ();
-static GLboolean _glewInit_GL_APPLE_element_array ();
-static GLboolean _glewInit_GL_APPLE_fence ();
-static GLboolean _glewInit_GL_APPLE_flush_buffer_range ();
-static GLboolean _glewInit_GL_APPLE_framebuffer_multisample ();
-static GLboolean _glewInit_GL_APPLE_object_purgeable ();
-static GLboolean _glewInit_GL_APPLE_sync ();
-static GLboolean _glewInit_GL_APPLE_texture_range ();
-static GLboolean _glewInit_GL_APPLE_vertex_array_object ();
-static GLboolean _glewInit_GL_APPLE_vertex_array_range ();
-static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators ();
-static GLboolean _glewInit_GL_ARB_ES2_compatibility ();
-static GLboolean _glewInit_GL_ARB_ES3_1_compatibility ();
-static GLboolean _glewInit_GL_ARB_ES3_2_compatibility ();
-static GLboolean _glewInit_GL_ARB_base_instance ();
-static GLboolean _glewInit_GL_ARB_bindless_texture ();
-static GLboolean _glewInit_GL_ARB_blend_func_extended ();
-static GLboolean _glewInit_GL_ARB_buffer_storage ();
-static GLboolean _glewInit_GL_ARB_cl_event ();
-static GLboolean _glewInit_GL_ARB_clear_buffer_object ();
-static GLboolean _glewInit_GL_ARB_clear_texture ();
-static GLboolean _glewInit_GL_ARB_clip_control ();
-static GLboolean _glewInit_GL_ARB_color_buffer_float ();
-static GLboolean _glewInit_GL_ARB_compute_shader ();
-static GLboolean _glewInit_GL_ARB_compute_variable_group_size ();
-static GLboolean _glewInit_GL_ARB_copy_buffer ();
-static GLboolean _glewInit_GL_ARB_copy_image ();
-static GLboolean _glewInit_GL_ARB_debug_output ();
-static GLboolean _glewInit_GL_ARB_direct_state_access ();
-static GLboolean _glewInit_GL_ARB_draw_buffers ();
-static GLboolean _glewInit_GL_ARB_draw_buffers_blend ();
-static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex ();
-static GLboolean _glewInit_GL_ARB_draw_indirect ();
-static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments ();
-static GLboolean _glewInit_GL_ARB_framebuffer_object ();
-static GLboolean _glewInit_GL_ARB_geometry_shader4 ();
-static GLboolean _glewInit_GL_ARB_get_program_binary ();
-static GLboolean _glewInit_GL_ARB_get_texture_sub_image ();
-static GLboolean _glewInit_GL_ARB_gl_spirv ();
-static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 ();
-static GLboolean _glewInit_GL_ARB_gpu_shader_int64 ();
-static GLboolean _glewInit_GL_ARB_imaging ();
-static GLboolean _glewInit_GL_ARB_indirect_parameters ();
-static GLboolean _glewInit_GL_ARB_instanced_arrays ();
-static GLboolean _glewInit_GL_ARB_internalformat_query ();
-static GLboolean _glewInit_GL_ARB_internalformat_query2 ();
-static GLboolean _glewInit_GL_ARB_invalidate_subdata ();
-static GLboolean _glewInit_GL_ARB_map_buffer_range ();
-static GLboolean _glewInit_GL_ARB_matrix_palette ();
-static GLboolean _glewInit_GL_ARB_multi_bind ();
-static GLboolean _glewInit_GL_ARB_multi_draw_indirect ();
-static GLboolean _glewInit_GL_ARB_multisample ();
-static GLboolean _glewInit_GL_ARB_multitexture ();
-static GLboolean _glewInit_GL_ARB_occlusion_query ();
-static GLboolean _glewInit_GL_ARB_parallel_shader_compile ();
-static GLboolean _glewInit_GL_ARB_point_parameters ();
-static GLboolean _glewInit_GL_ARB_polygon_offset_clamp ();
-static GLboolean _glewInit_GL_ARB_program_interface_query ();
-static GLboolean _glewInit_GL_ARB_provoking_vertex ();
-static GLboolean _glewInit_GL_ARB_robustness ();
-static GLboolean _glewInit_GL_ARB_sample_locations ();
-static GLboolean _glewInit_GL_ARB_sample_shading ();
-static GLboolean _glewInit_GL_ARB_sampler_objects ();
-static GLboolean _glewInit_GL_ARB_separate_shader_objects ();
-static GLboolean _glewInit_GL_ARB_shader_atomic_counters ();
-static GLboolean _glewInit_GL_ARB_shader_image_load_store ();
-static GLboolean _glewInit_GL_ARB_shader_objects ();
-static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object ();
-static GLboolean _glewInit_GL_ARB_shader_subroutine ();
-static GLboolean _glewInit_GL_ARB_shading_language_include ();
-static GLboolean _glewInit_GL_ARB_sparse_buffer ();
-static GLboolean _glewInit_GL_ARB_sparse_texture ();
-static GLboolean _glewInit_GL_ARB_sync ();
-static GLboolean _glewInit_GL_ARB_tessellation_shader ();
-static GLboolean _glewInit_GL_ARB_texture_barrier ();
-static GLboolean _glewInit_GL_ARB_texture_buffer_object ();
-static GLboolean _glewInit_GL_ARB_texture_buffer_range ();
-static GLboolean _glewInit_GL_ARB_texture_compression ();
-static GLboolean _glewInit_GL_ARB_texture_multisample ();
-static GLboolean _glewInit_GL_ARB_texture_storage ();
-static GLboolean _glewInit_GL_ARB_texture_storage_multisample ();
-static GLboolean _glewInit_GL_ARB_texture_view ();
-static GLboolean _glewInit_GL_ARB_timer_query ();
-static GLboolean _glewInit_GL_ARB_transform_feedback2 ();
-static GLboolean _glewInit_GL_ARB_transform_feedback3 ();
-static GLboolean _glewInit_GL_ARB_transform_feedback_instanced ();
-static GLboolean _glewInit_GL_ARB_transpose_matrix ();
-static GLboolean _glewInit_GL_ARB_uniform_buffer_object ();
-static GLboolean _glewInit_GL_ARB_vertex_array_object ();
-static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit ();
-static GLboolean _glewInit_GL_ARB_vertex_attrib_binding ();
-static GLboolean _glewInit_GL_ARB_vertex_blend ();
-static GLboolean _glewInit_GL_ARB_vertex_buffer_object ();
-static GLboolean _glewInit_GL_ARB_vertex_program ();
-static GLboolean _glewInit_GL_ARB_vertex_shader ();
-static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev ();
-static GLboolean _glewInit_GL_ARB_viewport_array ();
-static GLboolean _glewInit_GL_ARB_window_pos ();
-static GLboolean _glewInit_GL_ATI_draw_buffers ();
-static GLboolean _glewInit_GL_ATI_element_array ();
-static GLboolean _glewInit_GL_ATI_envmap_bumpmap ();
-static GLboolean _glewInit_GL_ATI_fragment_shader ();
-static GLboolean _glewInit_GL_ATI_map_object_buffer ();
-static GLboolean _glewInit_GL_ATI_pn_triangles ();
-static GLboolean _glewInit_GL_ATI_separate_stencil ();
-static GLboolean _glewInit_GL_ATI_vertex_array_object ();
-static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object ();
-static GLboolean _glewInit_GL_ATI_vertex_streams ();
-static GLboolean _glewInit_GL_EXT_EGL_image_storage ();
-static GLboolean _glewInit_GL_EXT_base_instance ();
-static GLboolean _glewInit_GL_EXT_bindable_uniform ();
-static GLboolean _glewInit_GL_EXT_blend_color ();
-static GLboolean _glewInit_GL_EXT_blend_equation_separate ();
-static GLboolean _glewInit_GL_EXT_blend_func_extended ();
-static GLboolean _glewInit_GL_EXT_blend_func_separate ();
-static GLboolean _glewInit_GL_EXT_blend_minmax ();
-static GLboolean _glewInit_GL_EXT_buffer_storage ();
-static GLboolean _glewInit_GL_EXT_clear_texture ();
-static GLboolean _glewInit_GL_EXT_clip_control ();
-static GLboolean _glewInit_GL_EXT_color_subtable ();
-static GLboolean _glewInit_GL_EXT_compiled_vertex_array ();
-static GLboolean _glewInit_GL_EXT_convolution ();
-static GLboolean _glewInit_GL_EXT_coordinate_frame ();
-static GLboolean _glewInit_GL_EXT_copy_image ();
-static GLboolean _glewInit_GL_EXT_copy_texture ();
-static GLboolean _glewInit_GL_EXT_cull_vertex ();
-static GLboolean _glewInit_GL_EXT_debug_label ();
-static GLboolean _glewInit_GL_EXT_debug_marker ();
-static GLboolean _glewInit_GL_EXT_depth_bounds_test ();
-static GLboolean _glewInit_GL_EXT_direct_state_access ();
-static GLboolean _glewInit_GL_EXT_discard_framebuffer ();
-static GLboolean _glewInit_GL_EXT_disjoint_timer_query ();
-static GLboolean _glewInit_GL_EXT_draw_buffers ();
-static GLboolean _glewInit_GL_EXT_draw_buffers2 ();
-static GLboolean _glewInit_GL_EXT_draw_buffers_indexed ();
-static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex ();
-static GLboolean _glewInit_GL_EXT_draw_instanced ();
-static GLboolean _glewInit_GL_EXT_draw_range_elements ();
-static GLboolean _glewInit_GL_EXT_draw_transform_feedback ();
-static GLboolean _glewInit_GL_EXT_external_buffer ();
-static GLboolean _glewInit_GL_EXT_fog_coord ();
-static GLboolean _glewInit_GL_EXT_fragment_lighting ();
-static GLboolean _glewInit_GL_EXT_framebuffer_blit ();
-static GLboolean _glewInit_GL_EXT_framebuffer_multisample ();
-static GLboolean _glewInit_GL_EXT_framebuffer_object ();
-static GLboolean _glewInit_GL_EXT_geometry_shader4 ();
-static GLboolean _glewInit_GL_EXT_gpu_program_parameters ();
-static GLboolean _glewInit_GL_EXT_gpu_shader4 ();
-static GLboolean _glewInit_GL_EXT_histogram ();
-static GLboolean _glewInit_GL_EXT_index_func ();
-static GLboolean _glewInit_GL_EXT_index_material ();
-static GLboolean _glewInit_GL_EXT_instanced_arrays ();
-static GLboolean _glewInit_GL_EXT_light_texture ();
-static GLboolean _glewInit_GL_EXT_map_buffer_range ();
-static GLboolean _glewInit_GL_EXT_memory_object ();
-static GLboolean _glewInit_GL_EXT_memory_object_fd ();
-static GLboolean _glewInit_GL_EXT_memory_object_win32 ();
-static GLboolean _glewInit_GL_EXT_multi_draw_arrays ();
-static GLboolean _glewInit_GL_EXT_multi_draw_indirect ();
-static GLboolean _glewInit_GL_EXT_multisample ();
-static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture ();
-static GLboolean _glewInit_GL_EXT_multiview_draw_buffers ();
-static GLboolean _glewInit_GL_EXT_paletted_texture ();
-static GLboolean _glewInit_GL_EXT_pixel_transform ();
-static GLboolean _glewInit_GL_EXT_point_parameters ();
-static GLboolean _glewInit_GL_EXT_polygon_offset ();
-static GLboolean _glewInit_GL_EXT_polygon_offset_clamp ();
-static GLboolean _glewInit_GL_EXT_primitive_bounding_box ();
-static GLboolean _glewInit_GL_EXT_provoking_vertex ();
-static GLboolean _glewInit_GL_EXT_raster_multisample ();
-static GLboolean _glewInit_GL_EXT_robustness ();
-static GLboolean _glewInit_GL_EXT_scene_marker ();
-static GLboolean _glewInit_GL_EXT_secondary_color ();
-static GLboolean _glewInit_GL_EXT_semaphore ();
-static GLboolean _glewInit_GL_EXT_semaphore_fd ();
-static GLboolean _glewInit_GL_EXT_semaphore_win32 ();
-static GLboolean _glewInit_GL_EXT_separate_shader_objects ();
-static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch ();
-static GLboolean _glewInit_GL_EXT_shader_image_load_store ();
-static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 ();
-static GLboolean _glewInit_GL_EXT_sparse_texture ();
-static GLboolean _glewInit_GL_EXT_stencil_two_side ();
-static GLboolean _glewInit_GL_EXT_subtexture ();
-static GLboolean _glewInit_GL_EXT_tessellation_point_size ();
-static GLboolean _glewInit_GL_EXT_texture3D ();
-static GLboolean _glewInit_GL_EXT_texture_array ();
-static GLboolean _glewInit_GL_EXT_texture_border_clamp ();
-static GLboolean _glewInit_GL_EXT_texture_buffer_object ();
-static GLboolean _glewInit_GL_EXT_texture_integer ();
-static GLboolean _glewInit_GL_EXT_texture_object ();
-static GLboolean _glewInit_GL_EXT_texture_perturb_normal ();
-static GLboolean _glewInit_GL_EXT_texture_storage ();
-static GLboolean _glewInit_GL_EXT_texture_view ();
-static GLboolean _glewInit_GL_EXT_timer_query ();
-static GLboolean _glewInit_GL_EXT_transform_feedback ();
-static GLboolean _glewInit_GL_EXT_vertex_array ();
-static GLboolean _glewInit_GL_EXT_vertex_array_setXXX ();
-static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit ();
-static GLboolean _glewInit_GL_EXT_vertex_shader ();
-static GLboolean _glewInit_GL_EXT_vertex_weighting ();
-static GLboolean _glewInit_GL_EXT_win32_keyed_mutex ();
-static GLboolean _glewInit_GL_EXT_window_rectangles ();
-static GLboolean _glewInit_GL_EXT_x11_sync_object ();
-static GLboolean _glewInit_GL_GREMEDY_frame_terminator ();
-static GLboolean _glewInit_GL_GREMEDY_string_marker ();
-static GLboolean _glewInit_GL_HP_image_transform ();
-static GLboolean _glewInit_GL_IBM_multimode_draw_arrays ();
-static GLboolean _glewInit_GL_IBM_vertex_array_lists ();
-static GLboolean _glewInit_GL_IMG_bindless_texture ();
-static GLboolean _glewInit_GL_IMG_framebuffer_downsample ();
-static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture ();
-static GLboolean _glewInit_GL_INTEL_map_texture ();
-static GLboolean _glewInit_GL_INTEL_parallel_arrays ();
-static GLboolean _glewInit_GL_INTEL_performance_query ();
-static GLboolean _glewInit_GL_INTEL_texture_scissor ();
-static GLboolean _glewInit_GL_KHR_blend_equation_advanced ();
-static GLboolean _glewInit_GL_KHR_debug ();
-static GLboolean _glewInit_GL_KHR_parallel_shader_compile ();
-static GLboolean _glewInit_GL_KHR_robustness ();
-static GLboolean _glewInit_GL_KTX_buffer_region ();
-static GLboolean _glewInit_GL_MESA_framebuffer_flip_y ();
-static GLboolean _glewInit_GL_MESA_resize_buffers ();
-static GLboolean _glewInit_GL_MESA_window_pos ();
-static GLboolean _glewInit_GL_NVX_conditional_render ();
-static GLboolean _glewInit_GL_NVX_gpu_multicast2 ();
-static GLboolean _glewInit_GL_NVX_linked_gpu_multicast ();
-static GLboolean _glewInit_GL_NVX_progress_fence ();
-static GLboolean _glewInit_GL_NV_3dvision_settings ();
-static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control ();
-static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect ();
-static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count ();
-static GLboolean _glewInit_GL_NV_bindless_texture ();
-static GLboolean _glewInit_GL_NV_blend_equation_advanced ();
-static GLboolean _glewInit_GL_NV_clip_space_w_scaling ();
-static GLboolean _glewInit_GL_NV_command_list ();
-static GLboolean _glewInit_GL_NV_conditional_render ();
-static GLboolean _glewInit_GL_NV_conservative_raster ();
-static GLboolean _glewInit_GL_NV_conservative_raster_dilate ();
-static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles ();
-static GLboolean _glewInit_GL_NV_copy_buffer ();
-static GLboolean _glewInit_GL_NV_copy_image ();
-static GLboolean _glewInit_GL_NV_depth_buffer_float ();
-static GLboolean _glewInit_GL_NV_draw_buffers ();
-static GLboolean _glewInit_GL_NV_draw_instanced ();
-static GLboolean _glewInit_GL_NV_draw_texture ();
-static GLboolean _glewInit_GL_NV_draw_vulkan_image ();
-static GLboolean _glewInit_GL_NV_evaluators ();
-static GLboolean _glewInit_GL_NV_explicit_multisample ();
-static GLboolean _glewInit_GL_NV_fence ();
-static GLboolean _glewInit_GL_NV_fragment_coverage_to_color ();
-static GLboolean _glewInit_GL_NV_fragment_program ();
-static GLboolean _glewInit_GL_NV_framebuffer_blit ();
-static GLboolean _glewInit_GL_NV_framebuffer_multisample ();
-static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage ();
-static GLboolean _glewInit_GL_NV_geometry_program4 ();
-static GLboolean _glewInit_GL_NV_gpu_multicast ();
-static GLboolean _glewInit_GL_NV_gpu_program4 ();
-static GLboolean _glewInit_GL_NV_gpu_shader5 ();
-static GLboolean _glewInit_GL_NV_half_float ();
-static GLboolean _glewInit_GL_NV_instanced_arrays ();
-static GLboolean _glewInit_GL_NV_internalformat_sample_query ();
-static GLboolean _glewInit_GL_NV_memory_attachment ();
-static GLboolean _glewInit_GL_NV_mesh_shader ();
-static GLboolean _glewInit_GL_NV_non_square_matrices ();
-static GLboolean _glewInit_GL_NV_occlusion_query ();
-static GLboolean _glewInit_GL_NV_parameter_buffer_object ();
-static GLboolean _glewInit_GL_NV_path_rendering ();
-static GLboolean _glewInit_GL_NV_pixel_data_range ();
-static GLboolean _glewInit_GL_NV_point_sprite ();
-static GLboolean _glewInit_GL_NV_polygon_mode ();
-static GLboolean _glewInit_GL_NV_present_video ();
-static GLboolean _glewInit_GL_NV_primitive_restart ();
-static GLboolean _glewInit_GL_NV_read_buffer ();
-static GLboolean _glewInit_GL_NV_register_combiners ();
-static GLboolean _glewInit_GL_NV_register_combiners2 ();
-static GLboolean _glewInit_GL_NV_sample_locations ();
-static GLboolean _glewInit_GL_NV_scissor_exclusive ();
-static GLboolean _glewInit_GL_NV_shader_buffer_load ();
-static GLboolean _glewInit_GL_NV_shading_rate_image ();
-static GLboolean _glewInit_GL_NV_texture_array ();
-static GLboolean _glewInit_GL_NV_texture_barrier ();
-static GLboolean _glewInit_GL_NV_texture_multisample ();
-static GLboolean _glewInit_GL_NV_transform_feedback ();
-static GLboolean _glewInit_GL_NV_transform_feedback2 ();
-static GLboolean _glewInit_GL_NV_vdpau_interop ();
-static GLboolean _glewInit_GL_NV_vdpau_interop2 ();
-static GLboolean _glewInit_GL_NV_vertex_array_range ();
-static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit ();
-static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory ();
-static GLboolean _glewInit_GL_NV_vertex_program ();
-static GLboolean _glewInit_GL_NV_video_capture ();
-static GLboolean _glewInit_GL_NV_viewport_array ();
-static GLboolean _glewInit_GL_NV_viewport_swizzle ();
-static GLboolean _glewInit_GL_OES_EGL_image ();
-static GLboolean _glewInit_GL_OES_blend_equation_separate ();
-static GLboolean _glewInit_GL_OES_blend_func_separate ();
-static GLboolean _glewInit_GL_OES_blend_subtract ();
-static GLboolean _glewInit_GL_OES_copy_image ();
-static GLboolean _glewInit_GL_OES_draw_buffers_indexed ();
-static GLboolean _glewInit_GL_OES_framebuffer_object ();
-static GLboolean _glewInit_GL_OES_get_program_binary ();
-static GLboolean _glewInit_GL_OES_mapbuffer ();
-static GLboolean _glewInit_GL_OES_matrix_palette ();
-static GLboolean _glewInit_GL_OES_sample_shading ();
-static GLboolean _glewInit_GL_OES_single_precision ();
-static GLboolean _glewInit_GL_OES_texture_3D ();
-static GLboolean _glewInit_GL_OES_texture_border_clamp ();
-static GLboolean _glewInit_GL_OES_texture_buffer ();
-static GLboolean _glewInit_GL_OES_texture_cube_map ();
-static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array ();
-static GLboolean _glewInit_GL_OES_texture_view ();
-static GLboolean _glewInit_GL_OES_vertex_array_object ();
-static GLboolean _glewInit_GL_OVR_multiview ();
-static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture ();
-static GLboolean _glewInit_GL_QCOM_alpha_test ();
-static GLboolean _glewInit_GL_QCOM_driver_control ();
-static GLboolean _glewInit_GL_QCOM_extended_get ();
-static GLboolean _glewInit_GL_QCOM_extended_get2 ();
-static GLboolean _glewInit_GL_QCOM_framebuffer_foveated ();
-static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent ();
-static GLboolean _glewInit_GL_QCOM_texture_foveated ();
-static GLboolean _glewInit_GL_QCOM_tiled_rendering ();
-static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility ();
-static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility ();
-static GLboolean _glewInit_GL_REGAL_error_string ();
-static GLboolean _glewInit_GL_REGAL_extension_query ();
-static GLboolean _glewInit_GL_REGAL_log ();
-static GLboolean _glewInit_GL_REGAL_proc_address ();
-static GLboolean _glewInit_GL_SGIS_detail_texture ();
-static GLboolean _glewInit_GL_SGIS_fog_function ();
-static GLboolean _glewInit_GL_SGIS_multisample ();
-static GLboolean _glewInit_GL_SGIS_multitexture ();
-static GLboolean _glewInit_GL_SGIS_shared_multisample ();
-static GLboolean _glewInit_GL_SGIS_sharpen_texture ();
-static GLboolean _glewInit_GL_SGIS_texture4D ();
-static GLboolean _glewInit_GL_SGIS_texture_filter4 ();
-static GLboolean _glewInit_GL_SGIX_async ();
-static GLboolean _glewInit_GL_SGIX_datapipe ();
-static GLboolean _glewInit_GL_SGIX_flush_raster ();
-static GLboolean _glewInit_GL_SGIX_fog_layers ();
-static GLboolean _glewInit_GL_SGIX_fog_texture ();
-static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting ();
-static GLboolean _glewInit_GL_SGIX_framezoom ();
-static GLboolean _glewInit_GL_SGIX_igloo_interface ();
-static GLboolean _glewInit_GL_SGIX_mpeg1 ();
-static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex ();
-static GLboolean _glewInit_GL_SGIX_pixel_texture ();
-static GLboolean _glewInit_GL_SGIX_polynomial_ffd ();
-static GLboolean _glewInit_GL_SGIX_quad_mesh ();
-static GLboolean _glewInit_GL_SGIX_reference_plane ();
-static GLboolean _glewInit_GL_SGIX_sprite ();
-static GLboolean _glewInit_GL_SGIX_tag_sample_buffer ();
-static GLboolean _glewInit_GL_SGIX_vector_ops ();
-static GLboolean _glewInit_GL_SGIX_vertex_array_object ();
-static GLboolean _glewInit_GL_SGI_color_table ();
-static GLboolean _glewInit_GL_SGI_fft ();
-static GLboolean _glewInit_GL_SUNX_constant_data ();
-static GLboolean _glewInit_GL_SUN_global_alpha ();
-static GLboolean _glewInit_GL_SUN_read_video_pixels ();
-static GLboolean _glewInit_GL_SUN_triangle_list ();
-static GLboolean _glewInit_GL_SUN_vertex ();
-static GLboolean _glewInit_GL_WIN_swap_hint ();
+static GLboolean _glewInit_GL_VERSION_1_2 (void);
+static GLboolean _glewInit_GL_VERSION_1_3 (void);
+static GLboolean _glewInit_GL_VERSION_1_4 (void);
+static GLboolean _glewInit_GL_VERSION_1_5 (void);
+static GLboolean _glewInit_GL_VERSION_2_0 (void);
+static GLboolean _glewInit_GL_VERSION_2_1 (void);
+static GLboolean _glewInit_GL_VERSION_3_0 (void);
+static GLboolean _glewInit_GL_VERSION_3_1 (void);
+static GLboolean _glewInit_GL_VERSION_3_2 (void);
+static GLboolean _glewInit_GL_VERSION_3_3 (void);
+static GLboolean _glewInit_GL_VERSION_4_0 (void);
+static GLboolean _glewInit_GL_VERSION_4_5 (void);
+static GLboolean _glewInit_GL_VERSION_4_6 (void);
+static GLboolean _glewInit_GL_3DFX_tbuffer (void);
+static GLboolean _glewInit_GL_AMD_debug_output (void);
+static GLboolean _glewInit_GL_AMD_draw_buffers_blend (void);
+static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced (void);
+static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions (void);
+static GLboolean _glewInit_GL_AMD_interleaved_elements (void);
+static GLboolean _glewInit_GL_AMD_multi_draw_indirect (void);
+static GLboolean _glewInit_GL_AMD_name_gen_delete (void);
+static GLboolean _glewInit_GL_AMD_occlusion_query_event (void);
+static GLboolean _glewInit_GL_AMD_performance_monitor (void);
+static GLboolean _glewInit_GL_AMD_sample_positions (void);
+static GLboolean _glewInit_GL_AMD_sparse_texture (void);
+static GLboolean _glewInit_GL_AMD_stencil_operation_extended (void);
+static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (void);
+static GLboolean _glewInit_GL_ANGLE_framebuffer_blit (void);
+static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (void);
+static GLboolean _glewInit_GL_ANGLE_instanced_arrays (void);
+static GLboolean _glewInit_GL_ANGLE_timer_query (void);
+static GLboolean _glewInit_GL_ANGLE_translated_shader_source (void);
+static GLboolean _glewInit_GL_APPLE_copy_texture_levels (void);
+static GLboolean _glewInit_GL_APPLE_element_array (void);
+static GLboolean _glewInit_GL_APPLE_fence (void);
+static GLboolean _glewInit_GL_APPLE_flush_buffer_range (void);
+static GLboolean _glewInit_GL_APPLE_framebuffer_multisample (void);
+static GLboolean _glewInit_GL_APPLE_object_purgeable (void);
+static GLboolean _glewInit_GL_APPLE_sync (void);
+static GLboolean _glewInit_GL_APPLE_texture_range (void);
+static GLboolean _glewInit_GL_APPLE_vertex_array_object (void);
+static GLboolean _glewInit_GL_APPLE_vertex_array_range (void);
+static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (void);
+static GLboolean _glewInit_GL_ARB_ES2_compatibility (void);
+static GLboolean _glewInit_GL_ARB_ES3_1_compatibility (void);
+static GLboolean _glewInit_GL_ARB_ES3_2_compatibility (void);
+static GLboolean _glewInit_GL_ARB_base_instance (void);
+static GLboolean _glewInit_GL_ARB_bindless_texture (void);
+static GLboolean _glewInit_GL_ARB_blend_func_extended (void);
+static GLboolean _glewInit_GL_ARB_buffer_storage (void);
+static GLboolean _glewInit_GL_ARB_cl_event (void);
+static GLboolean _glewInit_GL_ARB_clear_buffer_object (void);
+static GLboolean _glewInit_GL_ARB_clear_texture (void);
+static GLboolean _glewInit_GL_ARB_clip_control (void);
+static GLboolean _glewInit_GL_ARB_color_buffer_float (void);
+static GLboolean _glewInit_GL_ARB_compute_shader (void);
+static GLboolean _glewInit_GL_ARB_compute_variable_group_size (void);
+static GLboolean _glewInit_GL_ARB_copy_buffer (void);
+static GLboolean _glewInit_GL_ARB_copy_image (void);
+static GLboolean _glewInit_GL_ARB_debug_output (void);
+static GLboolean _glewInit_GL_ARB_direct_state_access (void);
+static GLboolean _glewInit_GL_ARB_draw_buffers (void);
+static GLboolean _glewInit_GL_ARB_draw_buffers_blend (void);
+static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (void);
+static GLboolean _glewInit_GL_ARB_draw_indirect (void);
+static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (void);
+static GLboolean _glewInit_GL_ARB_framebuffer_object (void);
+static GLboolean _glewInit_GL_ARB_geometry_shader4 (void);
+static GLboolean _glewInit_GL_ARB_get_program_binary (void);
+static GLboolean _glewInit_GL_ARB_get_texture_sub_image (void);
+static GLboolean _glewInit_GL_ARB_gl_spirv (void);
+static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (void);
+static GLboolean _glewInit_GL_ARB_gpu_shader_int64 (void);
+static GLboolean _glewInit_GL_ARB_imaging (void);
+static GLboolean _glewInit_GL_ARB_indirect_parameters (void);
+static GLboolean _glewInit_GL_ARB_instanced_arrays (void);
+static GLboolean _glewInit_GL_ARB_internalformat_query (void);
+static GLboolean _glewInit_GL_ARB_internalformat_query2 (void);
+static GLboolean _glewInit_GL_ARB_invalidate_subdata (void);
+static GLboolean _glewInit_GL_ARB_map_buffer_range (void);
+static GLboolean _glewInit_GL_ARB_matrix_palette (void);
+static GLboolean _glewInit_GL_ARB_multi_bind (void);
+static GLboolean _glewInit_GL_ARB_multi_draw_indirect (void);
+static GLboolean _glewInit_GL_ARB_multisample (void);
+static GLboolean _glewInit_GL_ARB_multitexture (void);
+static GLboolean _glewInit_GL_ARB_occlusion_query (void);
+static GLboolean _glewInit_GL_ARB_parallel_shader_compile (void);
+static GLboolean _glewInit_GL_ARB_point_parameters (void);
+static GLboolean _glewInit_GL_ARB_polygon_offset_clamp (void);
+static GLboolean _glewInit_GL_ARB_program_interface_query (void);
+static GLboolean _glewInit_GL_ARB_provoking_vertex (void);
+static GLboolean _glewInit_GL_ARB_robustness (void);
+static GLboolean _glewInit_GL_ARB_sample_locations (void);
+static GLboolean _glewInit_GL_ARB_sample_shading (void);
+static GLboolean _glewInit_GL_ARB_sampler_objects (void);
+static GLboolean _glewInit_GL_ARB_separate_shader_objects (void);
+static GLboolean _glewInit_GL_ARB_shader_atomic_counters (void);
+static GLboolean _glewInit_GL_ARB_shader_image_load_store (void);
+static GLboolean _glewInit_GL_ARB_shader_objects (void);
+static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (void);
+static GLboolean _glewInit_GL_ARB_shader_subroutine (void);
+static GLboolean _glewInit_GL_ARB_shading_language_include (void);
+static GLboolean _glewInit_GL_ARB_sparse_buffer (void);
+static GLboolean _glewInit_GL_ARB_sparse_texture (void);
+static GLboolean _glewInit_GL_ARB_sync (void);
+static GLboolean _glewInit_GL_ARB_tessellation_shader (void);
+static GLboolean _glewInit_GL_ARB_texture_barrier (void);
+static GLboolean _glewInit_GL_ARB_texture_buffer_object (void);
+static GLboolean _glewInit_GL_ARB_texture_buffer_range (void);
+static GLboolean _glewInit_GL_ARB_texture_compression (void);
+static GLboolean _glewInit_GL_ARB_texture_multisample (void);
+static GLboolean _glewInit_GL_ARB_texture_storage (void);
+static GLboolean _glewInit_GL_ARB_texture_storage_multisample (void);
+static GLboolean _glewInit_GL_ARB_texture_view (void);
+static GLboolean _glewInit_GL_ARB_timer_query (void);
+static GLboolean _glewInit_GL_ARB_transform_feedback2 (void);
+static GLboolean _glewInit_GL_ARB_transform_feedback3 (void);
+static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (void);
+static GLboolean _glewInit_GL_ARB_transpose_matrix (void);
+static GLboolean _glewInit_GL_ARB_uniform_buffer_object (void);
+static GLboolean _glewInit_GL_ARB_vertex_array_object (void);
+static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (void);
+static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (void);
+static GLboolean _glewInit_GL_ARB_vertex_blend (void);
+static GLboolean _glewInit_GL_ARB_vertex_buffer_object (void);
+static GLboolean _glewInit_GL_ARB_vertex_program (void);
+static GLboolean _glewInit_GL_ARB_vertex_shader (void);
+static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (void);
+static GLboolean _glewInit_GL_ARB_viewport_array (void);
+static GLboolean _glewInit_GL_ARB_window_pos (void);
+static GLboolean _glewInit_GL_ARM_shader_core_properties (void);
+static GLboolean _glewInit_GL_ATI_draw_buffers (void);
+static GLboolean _glewInit_GL_ATI_element_array (void);
+static GLboolean _glewInit_GL_ATI_envmap_bumpmap (void);
+static GLboolean _glewInit_GL_ATI_fragment_shader (void);
+static GLboolean _glewInit_GL_ATI_map_object_buffer (void);
+static GLboolean _glewInit_GL_ATI_pn_triangles (void);
+static GLboolean _glewInit_GL_ATI_separate_stencil (void);
+static GLboolean _glewInit_GL_ATI_vertex_array_object (void);
+static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (void);
+static GLboolean _glewInit_GL_ATI_vertex_streams (void);
+static GLboolean _glewInit_GL_EXT_EGL_image_storage (void);
+static GLboolean _glewInit_GL_EXT_base_instance (void);
+static GLboolean _glewInit_GL_EXT_bindable_uniform (void);
+static GLboolean _glewInit_GL_EXT_blend_color (void);
+static GLboolean _glewInit_GL_EXT_blend_equation_separate (void);
+static GLboolean _glewInit_GL_EXT_blend_func_extended (void);
+static GLboolean _glewInit_GL_EXT_blend_func_separate (void);
+static GLboolean _glewInit_GL_EXT_blend_minmax (void);
+static GLboolean _glewInit_GL_EXT_buffer_storage (void);
+static GLboolean _glewInit_GL_EXT_clear_texture (void);
+static GLboolean _glewInit_GL_EXT_clip_control (void);
+static GLboolean _glewInit_GL_EXT_color_subtable (void);
+static GLboolean _glewInit_GL_EXT_compiled_vertex_array (void);
+static GLboolean _glewInit_GL_EXT_convolution (void);
+static GLboolean _glewInit_GL_EXT_coordinate_frame (void);
+static GLboolean _glewInit_GL_EXT_copy_image (void);
+static GLboolean _glewInit_GL_EXT_copy_texture (void);
+static GLboolean _glewInit_GL_EXT_cull_vertex (void);
+static GLboolean _glewInit_GL_EXT_debug_label (void);
+static GLboolean _glewInit_GL_EXT_debug_marker (void);
+static GLboolean _glewInit_GL_EXT_depth_bounds_test (void);
+static GLboolean _glewInit_GL_EXT_direct_state_access (void);
+static GLboolean _glewInit_GL_EXT_discard_framebuffer (void);
+static GLboolean _glewInit_GL_EXT_disjoint_timer_query (void);
+static GLboolean _glewInit_GL_EXT_draw_buffers (void);
+static GLboolean _glewInit_GL_EXT_draw_buffers2 (void);
+static GLboolean _glewInit_GL_EXT_draw_buffers_indexed (void);
+static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex (void);
+static GLboolean _glewInit_GL_EXT_draw_instanced (void);
+static GLboolean _glewInit_GL_EXT_draw_range_elements (void);
+static GLboolean _glewInit_GL_EXT_draw_transform_feedback (void);
+static GLboolean _glewInit_GL_EXT_external_buffer (void);
+static GLboolean _glewInit_GL_EXT_fog_coord (void);
+static GLboolean _glewInit_GL_EXT_fragment_lighting (void);
+static GLboolean _glewInit_GL_EXT_fragment_shading_rate (void);
+static GLboolean _glewInit_GL_EXT_framebuffer_blit (void);
+static GLboolean _glewInit_GL_EXT_framebuffer_blit_layers (void);
+static GLboolean _glewInit_GL_EXT_framebuffer_multisample (void);
+static GLboolean _glewInit_GL_EXT_framebuffer_object (void);
+static GLboolean _glewInit_GL_EXT_geometry_shader4 (void);
+static GLboolean _glewInit_GL_EXT_gpu_program_parameters (void);
+static GLboolean _glewInit_GL_EXT_gpu_shader4 (void);
+static GLboolean _glewInit_GL_EXT_histogram (void);
+static GLboolean _glewInit_GL_EXT_index_func (void);
+static GLboolean _glewInit_GL_EXT_index_material (void);
+static GLboolean _glewInit_GL_EXT_instanced_arrays (void);
+static GLboolean _glewInit_GL_EXT_light_texture (void);
+static GLboolean _glewInit_GL_EXT_map_buffer_range (void);
+static GLboolean _glewInit_GL_EXT_memory_object (void);
+static GLboolean _glewInit_GL_EXT_memory_object_fd (void);
+static GLboolean _glewInit_GL_EXT_memory_object_win32 (void);
+static GLboolean _glewInit_GL_EXT_mesh_shader (void);
+static GLboolean _glewInit_GL_EXT_multi_draw_arrays (void);
+static GLboolean _glewInit_GL_EXT_multi_draw_indirect (void);
+static GLboolean _glewInit_GL_EXT_multisample (void);
+static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture (void);
+static GLboolean _glewInit_GL_EXT_multiview_draw_buffers (void);
+static GLboolean _glewInit_GL_EXT_paletted_texture (void);
+static GLboolean _glewInit_GL_EXT_pixel_transform (void);
+static GLboolean _glewInit_GL_EXT_point_parameters (void);
+static GLboolean _glewInit_GL_EXT_polygon_offset (void);
+static GLboolean _glewInit_GL_EXT_polygon_offset_clamp (void);
+static GLboolean _glewInit_GL_EXT_primitive_bounding_box (void);
+static GLboolean _glewInit_GL_EXT_provoking_vertex (void);
+static GLboolean _glewInit_GL_EXT_raster_multisample (void);
+static GLboolean _glewInit_GL_EXT_robustness (void);
+static GLboolean _glewInit_GL_EXT_scene_marker (void);
+static GLboolean _glewInit_GL_EXT_secondary_color (void);
+static GLboolean _glewInit_GL_EXT_semaphore (void);
+static GLboolean _glewInit_GL_EXT_semaphore_fd (void);
+static GLboolean _glewInit_GL_EXT_semaphore_win32 (void);
+static GLboolean _glewInit_GL_EXT_separate_shader_objects (void);
+static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch (void);
+static GLboolean _glewInit_GL_EXT_shader_image_load_store (void);
+static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 (void);
+static GLboolean _glewInit_GL_EXT_sparse_texture (void);
+static GLboolean _glewInit_GL_EXT_stencil_two_side (void);
+static GLboolean _glewInit_GL_EXT_subtexture (void);
+static GLboolean _glewInit_GL_EXT_tessellation_point_size (void);
+static GLboolean _glewInit_GL_EXT_texture3D (void);
+static GLboolean _glewInit_GL_EXT_texture_array (void);
+static GLboolean _glewInit_GL_EXT_texture_border_clamp (void);
+static GLboolean _glewInit_GL_EXT_texture_buffer_object (void);
+static GLboolean _glewInit_GL_EXT_texture_integer (void);
+static GLboolean _glewInit_GL_EXT_texture_object (void);
+static GLboolean _glewInit_GL_EXT_texture_perturb_normal (void);
+static GLboolean _glewInit_GL_EXT_texture_storage (void);
+static GLboolean _glewInit_GL_EXT_texture_storage_compression (void);
+static GLboolean _glewInit_GL_EXT_texture_view (void);
+static GLboolean _glewInit_GL_EXT_timer_query (void);
+static GLboolean _glewInit_GL_EXT_transform_feedback (void);
+static GLboolean _glewInit_GL_EXT_vertex_array (void);
+static GLboolean _glewInit_GL_EXT_vertex_array_setXXX (void);
+static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (void);
+static GLboolean _glewInit_GL_EXT_vertex_shader (void);
+static GLboolean _glewInit_GL_EXT_vertex_weighting (void);
+static GLboolean _glewInit_GL_EXT_win32_keyed_mutex (void);
+static GLboolean _glewInit_GL_EXT_window_rectangles (void);
+static GLboolean _glewInit_GL_EXT_x11_sync_object (void);
+static GLboolean _glewInit_GL_GREMEDY_frame_terminator (void);
+static GLboolean _glewInit_GL_GREMEDY_string_marker (void);
+static GLboolean _glewInit_GL_HP_image_transform (void);
+static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (void);
+static GLboolean _glewInit_GL_IBM_vertex_array_lists (void);
+static GLboolean _glewInit_GL_IMG_bindless_texture (void);
+static GLboolean _glewInit_GL_IMG_framebuffer_downsample (void);
+static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture (void);
+static GLboolean _glewInit_GL_INTEL_framebuffer_CMAA (void);
+static GLboolean _glewInit_GL_INTEL_map_texture (void);
+static GLboolean _glewInit_GL_INTEL_parallel_arrays (void);
+static GLboolean _glewInit_GL_INTEL_performance_query (void);
+static GLboolean _glewInit_GL_INTEL_texture_scissor (void);
+static GLboolean _glewInit_GL_KHR_blend_equation_advanced (void);
+static GLboolean _glewInit_GL_KHR_debug (void);
+static GLboolean _glewInit_GL_KHR_parallel_shader_compile (void);
+static GLboolean _glewInit_GL_KHR_robustness (void);
+static GLboolean _glewInit_GL_KTX_buffer_region (void);
+static GLboolean _glewInit_GL_MESA_framebuffer_flip_y (void);
+static GLboolean _glewInit_GL_MESA_resize_buffers (void);
+static GLboolean _glewInit_GL_MESA_window_pos (void);
+static GLboolean _glewInit_GL_NVX_conditional_render (void);
+static GLboolean _glewInit_GL_NVX_gpu_multicast2 (void);
+static GLboolean _glewInit_GL_NVX_linked_gpu_multicast (void);
+static GLboolean _glewInit_GL_NVX_progress_fence (void);
+static GLboolean _glewInit_GL_NV_3dvision_settings (void);
+static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control (void);
+static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (void);
+static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count (void);
+static GLboolean _glewInit_GL_NV_bindless_texture (void);
+static GLboolean _glewInit_GL_NV_blend_equation_advanced (void);
+static GLboolean _glewInit_GL_NV_clip_space_w_scaling (void);
+static GLboolean _glewInit_GL_NV_command_list (void);
+static GLboolean _glewInit_GL_NV_conditional_render (void);
+static GLboolean _glewInit_GL_NV_conservative_raster (void);
+static GLboolean _glewInit_GL_NV_conservative_raster_dilate (void);
+static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles (void);
+static GLboolean _glewInit_GL_NV_copy_buffer (void);
+static GLboolean _glewInit_GL_NV_copy_image (void);
+static GLboolean _glewInit_GL_NV_depth_buffer_float (void);
+static GLboolean _glewInit_GL_NV_draw_buffers (void);
+static GLboolean _glewInit_GL_NV_draw_instanced (void);
+static GLboolean _glewInit_GL_NV_draw_texture (void);
+static GLboolean _glewInit_GL_NV_draw_vulkan_image (void);
+static GLboolean _glewInit_GL_NV_evaluators (void);
+static GLboolean _glewInit_GL_NV_explicit_multisample (void);
+static GLboolean _glewInit_GL_NV_fence (void);
+static GLboolean _glewInit_GL_NV_fragment_coverage_to_color (void);
+static GLboolean _glewInit_GL_NV_fragment_program (void);
+static GLboolean _glewInit_GL_NV_framebuffer_blit (void);
+static GLboolean _glewInit_GL_NV_framebuffer_multisample (void);
+static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (void);
+static GLboolean _glewInit_GL_NV_geometry_program4 (void);
+static GLboolean _glewInit_GL_NV_gpu_multicast (void);
+static GLboolean _glewInit_GL_NV_gpu_program4 (void);
+static GLboolean _glewInit_GL_NV_gpu_shader5 (void);
+static GLboolean _glewInit_GL_NV_half_float (void);
+static GLboolean _glewInit_GL_NV_instanced_arrays (void);
+static GLboolean _glewInit_GL_NV_internalformat_sample_query (void);
+static GLboolean _glewInit_GL_NV_memory_attachment (void);
+static GLboolean _glewInit_GL_NV_memory_object_sparse (void);
+static GLboolean _glewInit_GL_NV_mesh_shader (void);
+static GLboolean _glewInit_GL_NV_non_square_matrices (void);
+static GLboolean _glewInit_GL_NV_occlusion_query (void);
+static GLboolean _glewInit_GL_NV_parameter_buffer_object (void);
+static GLboolean _glewInit_GL_NV_path_rendering (void);
+static GLboolean _glewInit_GL_NV_pixel_data_range (void);
+static GLboolean _glewInit_GL_NV_point_sprite (void);
+static GLboolean _glewInit_GL_NV_polygon_mode (void);
+static GLboolean _glewInit_GL_NV_present_video (void);
+static GLboolean _glewInit_GL_NV_primitive_restart (void);
+static GLboolean _glewInit_GL_NV_read_buffer (void);
+static GLboolean _glewInit_GL_NV_register_combiners (void);
+static GLboolean _glewInit_GL_NV_register_combiners2 (void);
+static GLboolean _glewInit_GL_NV_sample_locations (void);
+static GLboolean _glewInit_GL_NV_scissor_exclusive (void);
+static GLboolean _glewInit_GL_NV_shader_buffer_load (void);
+static GLboolean _glewInit_GL_NV_shading_rate_image (void);
+static GLboolean _glewInit_GL_NV_texture_array (void);
+static GLboolean _glewInit_GL_NV_texture_barrier (void);
+static GLboolean _glewInit_GL_NV_texture_multisample (void);
+static GLboolean _glewInit_GL_NV_timeline_semaphore (void);
+static GLboolean _glewInit_GL_NV_transform_feedback (void);
+static GLboolean _glewInit_GL_NV_transform_feedback2 (void);
+static GLboolean _glewInit_GL_NV_vdpau_interop (void);
+static GLboolean _glewInit_GL_NV_vdpau_interop2 (void);
+static GLboolean _glewInit_GL_NV_vertex_array_range (void);
+static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (void);
+static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (void);
+static GLboolean _glewInit_GL_NV_vertex_program (void);
+static GLboolean _glewInit_GL_NV_video_capture (void);
+static GLboolean _glewInit_GL_NV_viewport_array (void);
+static GLboolean _glewInit_GL_NV_viewport_swizzle (void);
+static GLboolean _glewInit_GL_OES_EGL_image (void);
+static GLboolean _glewInit_GL_OES_blend_equation_separate (void);
+static GLboolean _glewInit_GL_OES_blend_func_separate (void);
+static GLboolean _glewInit_GL_OES_blend_subtract (void);
+static GLboolean _glewInit_GL_OES_copy_image (void);
+static GLboolean _glewInit_GL_OES_draw_buffers_indexed (void);
+static GLboolean _glewInit_GL_OES_framebuffer_object (void);
+static GLboolean _glewInit_GL_OES_get_program_binary (void);
+static GLboolean _glewInit_GL_OES_mapbuffer (void);
+static GLboolean _glewInit_GL_OES_matrix_palette (void);
+static GLboolean _glewInit_GL_OES_sample_shading (void);
+static GLboolean _glewInit_GL_OES_single_precision (void);
+static GLboolean _glewInit_GL_OES_texture_3D (void);
+static GLboolean _glewInit_GL_OES_texture_border_clamp (void);
+static GLboolean _glewInit_GL_OES_texture_buffer (void);
+static GLboolean _glewInit_GL_OES_texture_cube_map (void);
+static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array (void);
+static GLboolean _glewInit_GL_OES_texture_view (void);
+static GLboolean _glewInit_GL_OES_vertex_array_object (void);
+static GLboolean _glewInit_GL_OVR_multiview (void);
+static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture (void);
+static GLboolean _glewInit_GL_QCOM_alpha_test (void);
+static GLboolean _glewInit_GL_QCOM_driver_control (void);
+static GLboolean _glewInit_GL_QCOM_extended_get (void);
+static GLboolean _glewInit_GL_QCOM_extended_get2 (void);
+static GLboolean _glewInit_GL_QCOM_frame_extrapolation (void);
+static GLboolean _glewInit_GL_QCOM_framebuffer_foveated (void);
+static GLboolean _glewInit_GL_QCOM_motion_estimation (void);
+static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent (void);
+static GLboolean _glewInit_GL_QCOM_shading_rate (void);
+static GLboolean _glewInit_GL_QCOM_texture_foveated (void);
+static GLboolean _glewInit_GL_QCOM_tiled_rendering (void);
+static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (void);
+static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (void);
+static GLboolean _glewInit_GL_REGAL_error_string (void);
+static GLboolean _glewInit_GL_REGAL_extension_query (void);
+static GLboolean _glewInit_GL_REGAL_log (void);
+static GLboolean _glewInit_GL_REGAL_proc_address (void);
+static GLboolean _glewInit_GL_SGIS_detail_texture (void);
+static GLboolean _glewInit_GL_SGIS_fog_function (void);
+static GLboolean _glewInit_GL_SGIS_multisample (void);
+static GLboolean _glewInit_GL_SGIS_multitexture (void);
+static GLboolean _glewInit_GL_SGIS_shared_multisample (void);
+static GLboolean _glewInit_GL_SGIS_sharpen_texture (void);
+static GLboolean _glewInit_GL_SGIS_texture4D (void);
+static GLboolean _glewInit_GL_SGIS_texture_filter4 (void);
+static GLboolean _glewInit_GL_SGIX_async (void);
+static GLboolean _glewInit_GL_SGIX_datapipe (void);
+static GLboolean _glewInit_GL_SGIX_flush_raster (void);
+static GLboolean _glewInit_GL_SGIX_fog_layers (void);
+static GLboolean _glewInit_GL_SGIX_fog_texture (void);
+static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (void);
+static GLboolean _glewInit_GL_SGIX_framezoom (void);
+static GLboolean _glewInit_GL_SGIX_igloo_interface (void);
+static GLboolean _glewInit_GL_SGIX_mpeg1 (void);
+static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex (void);
+static GLboolean _glewInit_GL_SGIX_pixel_texture (void);
+static GLboolean _glewInit_GL_SGIX_polynomial_ffd (void);
+static GLboolean _glewInit_GL_SGIX_quad_mesh (void);
+static GLboolean _glewInit_GL_SGIX_reference_plane (void);
+static GLboolean _glewInit_GL_SGIX_sprite (void);
+static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (void);
+static GLboolean _glewInit_GL_SGIX_vector_ops (void);
+static GLboolean _glewInit_GL_SGIX_vertex_array_object (void);
+static GLboolean _glewInit_GL_SGI_color_table (void);
+static GLboolean _glewInit_GL_SGI_fft (void);
+static GLboolean _glewInit_GL_SUNX_constant_data (void);
+static GLboolean _glewInit_GL_SUN_global_alpha (void);
+static GLboolean _glewInit_GL_SUN_read_video_pixels (void);
+static GLboolean _glewInit_GL_SUN_triangle_list (void);
+static GLboolean _glewInit_GL_SUN_vertex (void);
+static GLboolean _glewInit_GL_WIN_swap_hint (void);
 
 #ifdef GL_VERSION_1_2
 
-static GLboolean _glewInit_GL_VERSION_1_2 ()
+static GLboolean _glewInit_GL_VERSION_1_2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10412,7 +10703,7 @@ static GLboolean _glewInit_GL_VERSION_1_2 ()
 
 #ifdef GL_VERSION_1_3
 
-static GLboolean _glewInit_GL_VERSION_1_3 ()
+static GLboolean _glewInit_GL_VERSION_1_3 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10470,7 +10761,7 @@ static GLboolean _glewInit_GL_VERSION_1_3 ()
 
 #ifdef GL_VERSION_1_4
 
-static GLboolean _glewInit_GL_VERSION_1_4 ()
+static GLboolean _glewInit_GL_VERSION_1_4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10529,7 +10820,7 @@ static GLboolean _glewInit_GL_VERSION_1_4 ()
 
 #ifdef GL_VERSION_1_5
 
-static GLboolean _glewInit_GL_VERSION_1_5 ()
+static GLboolean _glewInit_GL_VERSION_1_5 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10560,7 +10851,7 @@ static GLboolean _glewInit_GL_VERSION_1_5 ()
 
 #ifdef GL_VERSION_2_0
 
-static GLboolean _glewInit_GL_VERSION_2_0 ()
+static GLboolean _glewInit_GL_VERSION_2_0 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10665,7 +10956,7 @@ static GLboolean _glewInit_GL_VERSION_2_0 ()
 
 #ifdef GL_VERSION_2_1
 
-static GLboolean _glewInit_GL_VERSION_2_1 ()
+static GLboolean _glewInit_GL_VERSION_2_1 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10683,7 +10974,7 @@ static GLboolean _glewInit_GL_VERSION_2_1 ()
 
 #ifdef GL_VERSION_3_0
 
-static GLboolean _glewInit_GL_VERSION_3_0 ()
+static GLboolean _glewInit_GL_VERSION_3_0 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10755,7 +11046,7 @@ static GLboolean _glewInit_GL_VERSION_3_0 ()
 
 #ifdef GL_VERSION_3_1
 
-static GLboolean _glewInit_GL_VERSION_3_1 ()
+static GLboolean _glewInit_GL_VERSION_3_1 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10773,7 +11064,7 @@ static GLboolean _glewInit_GL_VERSION_3_1 ()
 
 #ifdef GL_VERSION_3_2
 
-static GLboolean _glewInit_GL_VERSION_3_2 ()
+static GLboolean _glewInit_GL_VERSION_3_2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10793,7 +11084,7 @@ static GLboolean _glewInit_GL_VERSION_3_2 ()
 
 #ifdef GL_VERSION_3_3
 
-static GLboolean _glewInit_GL_VERSION_3_3 ()
+static GLboolean _glewInit_GL_VERSION_3_3 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10806,7 +11097,7 @@ static GLboolean _glewInit_GL_VERSION_3_3 ()
 
 #ifdef GL_VERSION_4_0
 
-static GLboolean _glewInit_GL_VERSION_4_0 ()
+static GLboolean _glewInit_GL_VERSION_4_0 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10823,7 +11114,7 @@ static GLboolean _glewInit_GL_VERSION_4_0 ()
 
 #ifdef GL_VERSION_4_5
 
-static GLboolean _glewInit_GL_VERSION_4_5 ()
+static GLboolean _glewInit_GL_VERSION_4_5 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10839,7 +11130,7 @@ static GLboolean _glewInit_GL_VERSION_4_5 ()
 
 #ifdef GL_VERSION_4_6
 
-static GLboolean _glewInit_GL_VERSION_4_6 ()
+static GLboolean _glewInit_GL_VERSION_4_6 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10854,7 +11145,7 @@ static GLboolean _glewInit_GL_VERSION_4_6 ()
 
 #ifdef GL_3DFX_tbuffer
 
-static GLboolean _glewInit_GL_3DFX_tbuffer ()
+static GLboolean _glewInit_GL_3DFX_tbuffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10867,7 +11158,7 @@ static GLboolean _glewInit_GL_3DFX_tbuffer ()
 
 #ifdef GL_AMD_debug_output
 
-static GLboolean _glewInit_GL_AMD_debug_output ()
+static GLboolean _glewInit_GL_AMD_debug_output (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10883,7 +11174,7 @@ static GLboolean _glewInit_GL_AMD_debug_output ()
 
 #ifdef GL_AMD_draw_buffers_blend
 
-static GLboolean _glewInit_GL_AMD_draw_buffers_blend ()
+static GLboolean _glewInit_GL_AMD_draw_buffers_blend (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10899,7 +11190,7 @@ static GLboolean _glewInit_GL_AMD_draw_buffers_blend ()
 
 #ifdef GL_AMD_framebuffer_multisample_advanced
 
-static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced ()
+static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10913,7 +11204,7 @@ static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced ()
 
 #ifdef GL_AMD_framebuffer_sample_positions
 
-static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions ()
+static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10929,7 +11220,7 @@ static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions ()
 
 #ifdef GL_AMD_interleaved_elements
 
-static GLboolean _glewInit_GL_AMD_interleaved_elements ()
+static GLboolean _glewInit_GL_AMD_interleaved_elements (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10942,7 +11233,7 @@ static GLboolean _glewInit_GL_AMD_interleaved_elements ()
 
 #ifdef GL_AMD_multi_draw_indirect
 
-static GLboolean _glewInit_GL_AMD_multi_draw_indirect ()
+static GLboolean _glewInit_GL_AMD_multi_draw_indirect (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10956,7 +11247,7 @@ static GLboolean _glewInit_GL_AMD_multi_draw_indirect ()
 
 #ifdef GL_AMD_name_gen_delete
 
-static GLboolean _glewInit_GL_AMD_name_gen_delete ()
+static GLboolean _glewInit_GL_AMD_name_gen_delete (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10971,7 +11262,7 @@ static GLboolean _glewInit_GL_AMD_name_gen_delete ()
 
 #ifdef GL_AMD_occlusion_query_event
 
-static GLboolean _glewInit_GL_AMD_occlusion_query_event ()
+static GLboolean _glewInit_GL_AMD_occlusion_query_event (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -10984,7 +11275,7 @@ static GLboolean _glewInit_GL_AMD_occlusion_query_event ()
 
 #ifdef GL_AMD_performance_monitor
 
-static GLboolean _glewInit_GL_AMD_performance_monitor ()
+static GLboolean _glewInit_GL_AMD_performance_monitor (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11007,7 +11298,7 @@ static GLboolean _glewInit_GL_AMD_performance_monitor ()
 
 #ifdef GL_AMD_sample_positions
 
-static GLboolean _glewInit_GL_AMD_sample_positions ()
+static GLboolean _glewInit_GL_AMD_sample_positions (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11020,7 +11311,7 @@ static GLboolean _glewInit_GL_AMD_sample_positions ()
 
 #ifdef GL_AMD_sparse_texture
 
-static GLboolean _glewInit_GL_AMD_sparse_texture ()
+static GLboolean _glewInit_GL_AMD_sparse_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11034,7 +11325,7 @@ static GLboolean _glewInit_GL_AMD_sparse_texture ()
 
 #ifdef GL_AMD_stencil_operation_extended
 
-static GLboolean _glewInit_GL_AMD_stencil_operation_extended ()
+static GLboolean _glewInit_GL_AMD_stencil_operation_extended (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11047,7 +11338,7 @@ static GLboolean _glewInit_GL_AMD_stencil_operation_extended ()
 
 #ifdef GL_AMD_vertex_shader_tessellator
 
-static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator ()
+static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11061,7 +11352,7 @@ static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator ()
 
 #ifdef GL_ANGLE_framebuffer_blit
 
-static GLboolean _glewInit_GL_ANGLE_framebuffer_blit ()
+static GLboolean _glewInit_GL_ANGLE_framebuffer_blit (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11074,7 +11365,7 @@ static GLboolean _glewInit_GL_ANGLE_framebuffer_blit ()
 
 #ifdef GL_ANGLE_framebuffer_multisample
 
-static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample ()
+static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11087,7 +11378,7 @@ static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample ()
 
 #ifdef GL_ANGLE_instanced_arrays
 
-static GLboolean _glewInit_GL_ANGLE_instanced_arrays ()
+static GLboolean _glewInit_GL_ANGLE_instanced_arrays (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11102,7 +11393,7 @@ static GLboolean _glewInit_GL_ANGLE_instanced_arrays ()
 
 #ifdef GL_ANGLE_timer_query
 
-static GLboolean _glewInit_GL_ANGLE_timer_query ()
+static GLboolean _glewInit_GL_ANGLE_timer_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11125,7 +11416,7 @@ static GLboolean _glewInit_GL_ANGLE_timer_query ()
 
 #ifdef GL_ANGLE_translated_shader_source
 
-static GLboolean _glewInit_GL_ANGLE_translated_shader_source ()
+static GLboolean _glewInit_GL_ANGLE_translated_shader_source (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11138,7 +11429,7 @@ static GLboolean _glewInit_GL_ANGLE_translated_shader_source ()
 
 #ifdef GL_APPLE_copy_texture_levels
 
-static GLboolean _glewInit_GL_APPLE_copy_texture_levels ()
+static GLboolean _glewInit_GL_APPLE_copy_texture_levels (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11151,7 +11442,7 @@ static GLboolean _glewInit_GL_APPLE_copy_texture_levels ()
 
 #ifdef GL_APPLE_element_array
 
-static GLboolean _glewInit_GL_APPLE_element_array ()
+static GLboolean _glewInit_GL_APPLE_element_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11168,7 +11459,7 @@ static GLboolean _glewInit_GL_APPLE_element_array ()
 
 #ifdef GL_APPLE_fence
 
-static GLboolean _glewInit_GL_APPLE_fence ()
+static GLboolean _glewInit_GL_APPLE_fence (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11188,7 +11479,7 @@ static GLboolean _glewInit_GL_APPLE_fence ()
 
 #ifdef GL_APPLE_flush_buffer_range
 
-static GLboolean _glewInit_GL_APPLE_flush_buffer_range ()
+static GLboolean _glewInit_GL_APPLE_flush_buffer_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11202,7 +11493,7 @@ static GLboolean _glewInit_GL_APPLE_flush_buffer_range ()
 
 #ifdef GL_APPLE_framebuffer_multisample
 
-static GLboolean _glewInit_GL_APPLE_framebuffer_multisample ()
+static GLboolean _glewInit_GL_APPLE_framebuffer_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11216,7 +11507,7 @@ static GLboolean _glewInit_GL_APPLE_framebuffer_multisample ()
 
 #ifdef GL_APPLE_object_purgeable
 
-static GLboolean _glewInit_GL_APPLE_object_purgeable ()
+static GLboolean _glewInit_GL_APPLE_object_purgeable (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11231,7 +11522,7 @@ static GLboolean _glewInit_GL_APPLE_object_purgeable ()
 
 #ifdef GL_APPLE_sync
 
-static GLboolean _glewInit_GL_APPLE_sync ()
+static GLboolean _glewInit_GL_APPLE_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11250,7 +11541,7 @@ static GLboolean _glewInit_GL_APPLE_sync ()
 
 #ifdef GL_APPLE_texture_range
 
-static GLboolean _glewInit_GL_APPLE_texture_range ()
+static GLboolean _glewInit_GL_APPLE_texture_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11264,7 +11555,7 @@ static GLboolean _glewInit_GL_APPLE_texture_range ()
 
 #ifdef GL_APPLE_vertex_array_object
 
-static GLboolean _glewInit_GL_APPLE_vertex_array_object ()
+static GLboolean _glewInit_GL_APPLE_vertex_array_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11280,7 +11571,7 @@ static GLboolean _glewInit_GL_APPLE_vertex_array_object ()
 
 #ifdef GL_APPLE_vertex_array_range
 
-static GLboolean _glewInit_GL_APPLE_vertex_array_range ()
+static GLboolean _glewInit_GL_APPLE_vertex_array_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11295,7 +11586,7 @@ static GLboolean _glewInit_GL_APPLE_vertex_array_range ()
 
 #ifdef GL_APPLE_vertex_program_evaluators
 
-static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators ()
+static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11314,7 +11605,7 @@ static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators ()
 
 #ifdef GL_ARB_ES2_compatibility
 
-static GLboolean _glewInit_GL_ARB_ES2_compatibility ()
+static GLboolean _glewInit_GL_ARB_ES2_compatibility (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11331,7 +11622,7 @@ static GLboolean _glewInit_GL_ARB_ES2_compatibility ()
 
 #ifdef GL_ARB_ES3_1_compatibility
 
-static GLboolean _glewInit_GL_ARB_ES3_1_compatibility ()
+static GLboolean _glewInit_GL_ARB_ES3_1_compatibility (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11344,7 +11635,7 @@ static GLboolean _glewInit_GL_ARB_ES3_1_compatibility ()
 
 #ifdef GL_ARB_ES3_2_compatibility
 
-static GLboolean _glewInit_GL_ARB_ES3_2_compatibility ()
+static GLboolean _glewInit_GL_ARB_ES3_2_compatibility (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11357,7 +11648,7 @@ static GLboolean _glewInit_GL_ARB_ES3_2_compatibility ()
 
 #ifdef GL_ARB_base_instance
 
-static GLboolean _glewInit_GL_ARB_base_instance ()
+static GLboolean _glewInit_GL_ARB_base_instance (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11372,7 +11663,7 @@ static GLboolean _glewInit_GL_ARB_base_instance ()
 
 #ifdef GL_ARB_bindless_texture
 
-static GLboolean _glewInit_GL_ARB_bindless_texture ()
+static GLboolean _glewInit_GL_ARB_bindless_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11400,7 +11691,7 @@ static GLboolean _glewInit_GL_ARB_bindless_texture ()
 
 #ifdef GL_ARB_blend_func_extended
 
-static GLboolean _glewInit_GL_ARB_blend_func_extended ()
+static GLboolean _glewInit_GL_ARB_blend_func_extended (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11414,7 +11705,7 @@ static GLboolean _glewInit_GL_ARB_blend_func_extended ()
 
 #ifdef GL_ARB_buffer_storage
 
-static GLboolean _glewInit_GL_ARB_buffer_storage ()
+static GLboolean _glewInit_GL_ARB_buffer_storage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11427,7 +11718,7 @@ static GLboolean _glewInit_GL_ARB_buffer_storage ()
 
 #ifdef GL_ARB_cl_event
 
-static GLboolean _glewInit_GL_ARB_cl_event ()
+static GLboolean _glewInit_GL_ARB_cl_event (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11440,7 +11731,7 @@ static GLboolean _glewInit_GL_ARB_cl_event ()
 
 #ifdef GL_ARB_clear_buffer_object
 
-static GLboolean _glewInit_GL_ARB_clear_buffer_object ()
+static GLboolean _glewInit_GL_ARB_clear_buffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11456,7 +11747,7 @@ static GLboolean _glewInit_GL_ARB_clear_buffer_object ()
 
 #ifdef GL_ARB_clear_texture
 
-static GLboolean _glewInit_GL_ARB_clear_texture ()
+static GLboolean _glewInit_GL_ARB_clear_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11470,7 +11761,7 @@ static GLboolean _glewInit_GL_ARB_clear_texture ()
 
 #ifdef GL_ARB_clip_control
 
-static GLboolean _glewInit_GL_ARB_clip_control ()
+static GLboolean _glewInit_GL_ARB_clip_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11483,7 +11774,7 @@ static GLboolean _glewInit_GL_ARB_clip_control ()
 
 #ifdef GL_ARB_color_buffer_float
 
-static GLboolean _glewInit_GL_ARB_color_buffer_float ()
+static GLboolean _glewInit_GL_ARB_color_buffer_float (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11496,7 +11787,7 @@ static GLboolean _glewInit_GL_ARB_color_buffer_float ()
 
 #ifdef GL_ARB_compute_shader
 
-static GLboolean _glewInit_GL_ARB_compute_shader ()
+static GLboolean _glewInit_GL_ARB_compute_shader (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11510,7 +11801,7 @@ static GLboolean _glewInit_GL_ARB_compute_shader ()
 
 #ifdef GL_ARB_compute_variable_group_size
 
-static GLboolean _glewInit_GL_ARB_compute_variable_group_size ()
+static GLboolean _glewInit_GL_ARB_compute_variable_group_size (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11523,7 +11814,7 @@ static GLboolean _glewInit_GL_ARB_compute_variable_group_size ()
 
 #ifdef GL_ARB_copy_buffer
 
-static GLboolean _glewInit_GL_ARB_copy_buffer ()
+static GLboolean _glewInit_GL_ARB_copy_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11536,7 +11827,7 @@ static GLboolean _glewInit_GL_ARB_copy_buffer ()
 
 #ifdef GL_ARB_copy_image
 
-static GLboolean _glewInit_GL_ARB_copy_image ()
+static GLboolean _glewInit_GL_ARB_copy_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11549,7 +11840,7 @@ static GLboolean _glewInit_GL_ARB_copy_image ()
 
 #ifdef GL_ARB_debug_output
 
-static GLboolean _glewInit_GL_ARB_debug_output ()
+static GLboolean _glewInit_GL_ARB_debug_output (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11565,7 +11856,7 @@ static GLboolean _glewInit_GL_ARB_debug_output ()
 
 #ifdef GL_ARB_direct_state_access
 
-static GLboolean _glewInit_GL_ARB_direct_state_access ()
+static GLboolean _glewInit_GL_ARB_direct_state_access (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11674,7 +11965,7 @@ static GLboolean _glewInit_GL_ARB_direct_state_access ()
 
 #ifdef GL_ARB_draw_buffers
 
-static GLboolean _glewInit_GL_ARB_draw_buffers ()
+static GLboolean _glewInit_GL_ARB_draw_buffers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11687,7 +11978,7 @@ static GLboolean _glewInit_GL_ARB_draw_buffers ()
 
 #ifdef GL_ARB_draw_buffers_blend
 
-static GLboolean _glewInit_GL_ARB_draw_buffers_blend ()
+static GLboolean _glewInit_GL_ARB_draw_buffers_blend (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11703,7 +11994,7 @@ static GLboolean _glewInit_GL_ARB_draw_buffers_blend ()
 
 #ifdef GL_ARB_draw_elements_base_vertex
 
-static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex ()
+static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11719,7 +12010,7 @@ static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex ()
 
 #ifdef GL_ARB_draw_indirect
 
-static GLboolean _glewInit_GL_ARB_draw_indirect ()
+static GLboolean _glewInit_GL_ARB_draw_indirect (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11733,7 +12024,7 @@ static GLboolean _glewInit_GL_ARB_draw_indirect ()
 
 #ifdef GL_ARB_framebuffer_no_attachments
 
-static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments ()
+static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11749,7 +12040,7 @@ static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments ()
 
 #ifdef GL_ARB_framebuffer_object
 
-static GLboolean _glewInit_GL_ARB_framebuffer_object ()
+static GLboolean _glewInit_GL_ARB_framebuffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11781,7 +12072,7 @@ static GLboolean _glewInit_GL_ARB_framebuffer_object ()
 
 #ifdef GL_ARB_geometry_shader4
 
-static GLboolean _glewInit_GL_ARB_geometry_shader4 ()
+static GLboolean _glewInit_GL_ARB_geometry_shader4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11797,7 +12088,7 @@ static GLboolean _glewInit_GL_ARB_geometry_shader4 ()
 
 #ifdef GL_ARB_get_program_binary
 
-static GLboolean _glewInit_GL_ARB_get_program_binary ()
+static GLboolean _glewInit_GL_ARB_get_program_binary (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11812,7 +12103,7 @@ static GLboolean _glewInit_GL_ARB_get_program_binary ()
 
 #ifdef GL_ARB_get_texture_sub_image
 
-static GLboolean _glewInit_GL_ARB_get_texture_sub_image ()
+static GLboolean _glewInit_GL_ARB_get_texture_sub_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11826,7 +12117,7 @@ static GLboolean _glewInit_GL_ARB_get_texture_sub_image ()
 
 #ifdef GL_ARB_gl_spirv
 
-static GLboolean _glewInit_GL_ARB_gl_spirv ()
+static GLboolean _glewInit_GL_ARB_gl_spirv (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11839,7 +12130,7 @@ static GLboolean _glewInit_GL_ARB_gl_spirv ()
 
 #ifdef GL_ARB_gpu_shader_fp64
 
-static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 ()
+static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11869,7 +12160,7 @@ static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 ()
 
 #ifdef GL_ARB_gpu_shader_int64
 
-static GLboolean _glewInit_GL_ARB_gpu_shader_int64 ()
+static GLboolean _glewInit_GL_ARB_gpu_shader_int64 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11917,7 +12208,7 @@ static GLboolean _glewInit_GL_ARB_gpu_shader_int64 ()
 
 #ifdef GL_ARB_imaging
 
-static GLboolean _glewInit_GL_ARB_imaging ()
+static GLboolean _glewInit_GL_ARB_imaging (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11962,7 +12253,7 @@ static GLboolean _glewInit_GL_ARB_imaging ()
 
 #ifdef GL_ARB_indirect_parameters
 
-static GLboolean _glewInit_GL_ARB_indirect_parameters ()
+static GLboolean _glewInit_GL_ARB_indirect_parameters (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11976,7 +12267,7 @@ static GLboolean _glewInit_GL_ARB_indirect_parameters ()
 
 #ifdef GL_ARB_instanced_arrays
 
-static GLboolean _glewInit_GL_ARB_instanced_arrays ()
+static GLboolean _glewInit_GL_ARB_instanced_arrays (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -11991,7 +12282,7 @@ static GLboolean _glewInit_GL_ARB_instanced_arrays ()
 
 #ifdef GL_ARB_internalformat_query
 
-static GLboolean _glewInit_GL_ARB_internalformat_query ()
+static GLboolean _glewInit_GL_ARB_internalformat_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12004,7 +12295,7 @@ static GLboolean _glewInit_GL_ARB_internalformat_query ()
 
 #ifdef GL_ARB_internalformat_query2
 
-static GLboolean _glewInit_GL_ARB_internalformat_query2 ()
+static GLboolean _glewInit_GL_ARB_internalformat_query2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12017,7 +12308,7 @@ static GLboolean _glewInit_GL_ARB_internalformat_query2 ()
 
 #ifdef GL_ARB_invalidate_subdata
 
-static GLboolean _glewInit_GL_ARB_invalidate_subdata ()
+static GLboolean _glewInit_GL_ARB_invalidate_subdata (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12035,7 +12326,7 @@ static GLboolean _glewInit_GL_ARB_invalidate_subdata ()
 
 #ifdef GL_ARB_map_buffer_range
 
-static GLboolean _glewInit_GL_ARB_map_buffer_range ()
+static GLboolean _glewInit_GL_ARB_map_buffer_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12049,7 +12340,7 @@ static GLboolean _glewInit_GL_ARB_map_buffer_range ()
 
 #ifdef GL_ARB_matrix_palette
 
-static GLboolean _glewInit_GL_ARB_matrix_palette ()
+static GLboolean _glewInit_GL_ARB_matrix_palette (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12066,7 +12357,7 @@ static GLboolean _glewInit_GL_ARB_matrix_palette ()
 
 #ifdef GL_ARB_multi_bind
 
-static GLboolean _glewInit_GL_ARB_multi_bind ()
+static GLboolean _glewInit_GL_ARB_multi_bind (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12084,7 +12375,7 @@ static GLboolean _glewInit_GL_ARB_multi_bind ()
 
 #ifdef GL_ARB_multi_draw_indirect
 
-static GLboolean _glewInit_GL_ARB_multi_draw_indirect ()
+static GLboolean _glewInit_GL_ARB_multi_draw_indirect (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12098,7 +12389,7 @@ static GLboolean _glewInit_GL_ARB_multi_draw_indirect ()
 
 #ifdef GL_ARB_multisample
 
-static GLboolean _glewInit_GL_ARB_multisample ()
+static GLboolean _glewInit_GL_ARB_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12111,7 +12402,7 @@ static GLboolean _glewInit_GL_ARB_multisample ()
 
 #ifdef GL_ARB_multitexture
 
-static GLboolean _glewInit_GL_ARB_multitexture ()
+static GLboolean _glewInit_GL_ARB_multitexture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12157,7 +12448,7 @@ static GLboolean _glewInit_GL_ARB_multitexture ()
 
 #ifdef GL_ARB_occlusion_query
 
-static GLboolean _glewInit_GL_ARB_occlusion_query ()
+static GLboolean _glewInit_GL_ARB_occlusion_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12177,7 +12468,7 @@ static GLboolean _glewInit_GL_ARB_occlusion_query ()
 
 #ifdef GL_ARB_parallel_shader_compile
 
-static GLboolean _glewInit_GL_ARB_parallel_shader_compile ()
+static GLboolean _glewInit_GL_ARB_parallel_shader_compile (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12190,7 +12481,7 @@ static GLboolean _glewInit_GL_ARB_parallel_shader_compile ()
 
 #ifdef GL_ARB_point_parameters
 
-static GLboolean _glewInit_GL_ARB_point_parameters ()
+static GLboolean _glewInit_GL_ARB_point_parameters (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12204,7 +12495,7 @@ static GLboolean _glewInit_GL_ARB_point_parameters ()
 
 #ifdef GL_ARB_polygon_offset_clamp
 
-static GLboolean _glewInit_GL_ARB_polygon_offset_clamp ()
+static GLboolean _glewInit_GL_ARB_polygon_offset_clamp (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12217,7 +12508,7 @@ static GLboolean _glewInit_GL_ARB_polygon_offset_clamp ()
 
 #ifdef GL_ARB_program_interface_query
 
-static GLboolean _glewInit_GL_ARB_program_interface_query ()
+static GLboolean _glewInit_GL_ARB_program_interface_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12235,7 +12526,7 @@ static GLboolean _glewInit_GL_ARB_program_interface_query ()
 
 #ifdef GL_ARB_provoking_vertex
 
-static GLboolean _glewInit_GL_ARB_provoking_vertex ()
+static GLboolean _glewInit_GL_ARB_provoking_vertex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12248,7 +12539,7 @@ static GLboolean _glewInit_GL_ARB_provoking_vertex ()
 
 #ifdef GL_ARB_robustness
 
-static GLboolean _glewInit_GL_ARB_robustness ()
+static GLboolean _glewInit_GL_ARB_robustness (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12280,10 +12571,11 @@ static GLboolean _glewInit_GL_ARB_robustness ()
 
 #ifdef GL_ARB_sample_locations
 
-static GLboolean _glewInit_GL_ARB_sample_locations ()
+static GLboolean _glewInit_GL_ARB_sample_locations (void)
 {
   GLboolean r = GL_FALSE;
 
+  r = ((glEvaluateDepthValuesARB = (PFNGLEVALUATEDEPTHVALUESARBPROC)glewGetProcAddress((const GLubyte*)"glEvaluateDepthValuesARB")) == NULL) || r;
   r = ((glFramebufferSampleLocationsfvARB = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSampleLocationsfvARB")) == NULL) || r;
   r = ((glNamedFramebufferSampleLocationsfvARB = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSampleLocationsfvARB")) == NULL) || r;
 
@@ -12294,7 +12586,7 @@ static GLboolean _glewInit_GL_ARB_sample_locations ()
 
 #ifdef GL_ARB_sample_shading
 
-static GLboolean _glewInit_GL_ARB_sample_shading ()
+static GLboolean _glewInit_GL_ARB_sample_shading (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12307,7 +12599,7 @@ static GLboolean _glewInit_GL_ARB_sample_shading ()
 
 #ifdef GL_ARB_sampler_objects
 
-static GLboolean _glewInit_GL_ARB_sampler_objects ()
+static GLboolean _glewInit_GL_ARB_sampler_objects (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12333,7 +12625,7 @@ static GLboolean _glewInit_GL_ARB_sampler_objects ()
 
 #ifdef GL_ARB_separate_shader_objects
 
-static GLboolean _glewInit_GL_ARB_separate_shader_objects ()
+static GLboolean _glewInit_GL_ARB_separate_shader_objects (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12405,7 +12697,7 @@ static GLboolean _glewInit_GL_ARB_separate_shader_objects ()
 
 #ifdef GL_ARB_shader_atomic_counters
 
-static GLboolean _glewInit_GL_ARB_shader_atomic_counters ()
+static GLboolean _glewInit_GL_ARB_shader_atomic_counters (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12418,7 +12710,7 @@ static GLboolean _glewInit_GL_ARB_shader_atomic_counters ()
 
 #ifdef GL_ARB_shader_image_load_store
 
-static GLboolean _glewInit_GL_ARB_shader_image_load_store ()
+static GLboolean _glewInit_GL_ARB_shader_image_load_store (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12432,7 +12724,7 @@ static GLboolean _glewInit_GL_ARB_shader_image_load_store ()
 
 #ifdef GL_ARB_shader_objects
 
-static GLboolean _glewInit_GL_ARB_shader_objects ()
+static GLboolean _glewInit_GL_ARB_shader_objects (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12483,7 +12775,7 @@ static GLboolean _glewInit_GL_ARB_shader_objects ()
 
 #ifdef GL_ARB_shader_storage_buffer_object
 
-static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object ()
+static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12496,7 +12788,7 @@ static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object ()
 
 #ifdef GL_ARB_shader_subroutine
 
-static GLboolean _glewInit_GL_ARB_shader_subroutine ()
+static GLboolean _glewInit_GL_ARB_shader_subroutine (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12516,7 +12808,7 @@ static GLboolean _glewInit_GL_ARB_shader_subroutine ()
 
 #ifdef GL_ARB_shading_language_include
 
-static GLboolean _glewInit_GL_ARB_shading_language_include ()
+static GLboolean _glewInit_GL_ARB_shading_language_include (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12534,7 +12826,7 @@ static GLboolean _glewInit_GL_ARB_shading_language_include ()
 
 #ifdef GL_ARB_sparse_buffer
 
-static GLboolean _glewInit_GL_ARB_sparse_buffer ()
+static GLboolean _glewInit_GL_ARB_sparse_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12547,7 +12839,7 @@ static GLboolean _glewInit_GL_ARB_sparse_buffer ()
 
 #ifdef GL_ARB_sparse_texture
 
-static GLboolean _glewInit_GL_ARB_sparse_texture ()
+static GLboolean _glewInit_GL_ARB_sparse_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12560,7 +12852,7 @@ static GLboolean _glewInit_GL_ARB_sparse_texture ()
 
 #ifdef GL_ARB_sync
 
-static GLboolean _glewInit_GL_ARB_sync ()
+static GLboolean _glewInit_GL_ARB_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12579,7 +12871,7 @@ static GLboolean _glewInit_GL_ARB_sync ()
 
 #ifdef GL_ARB_tessellation_shader
 
-static GLboolean _glewInit_GL_ARB_tessellation_shader ()
+static GLboolean _glewInit_GL_ARB_tessellation_shader (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12593,7 +12885,7 @@ static GLboolean _glewInit_GL_ARB_tessellation_shader ()
 
 #ifdef GL_ARB_texture_barrier
 
-static GLboolean _glewInit_GL_ARB_texture_barrier ()
+static GLboolean _glewInit_GL_ARB_texture_barrier (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12606,7 +12898,7 @@ static GLboolean _glewInit_GL_ARB_texture_barrier ()
 
 #ifdef GL_ARB_texture_buffer_object
 
-static GLboolean _glewInit_GL_ARB_texture_buffer_object ()
+static GLboolean _glewInit_GL_ARB_texture_buffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12619,7 +12911,7 @@ static GLboolean _glewInit_GL_ARB_texture_buffer_object ()
 
 #ifdef GL_ARB_texture_buffer_range
 
-static GLboolean _glewInit_GL_ARB_texture_buffer_range ()
+static GLboolean _glewInit_GL_ARB_texture_buffer_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12633,7 +12925,7 @@ static GLboolean _glewInit_GL_ARB_texture_buffer_range ()
 
 #ifdef GL_ARB_texture_compression
 
-static GLboolean _glewInit_GL_ARB_texture_compression ()
+static GLboolean _glewInit_GL_ARB_texture_compression (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12652,7 +12944,7 @@ static GLboolean _glewInit_GL_ARB_texture_compression ()
 
 #ifdef GL_ARB_texture_multisample
 
-static GLboolean _glewInit_GL_ARB_texture_multisample ()
+static GLboolean _glewInit_GL_ARB_texture_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12668,7 +12960,7 @@ static GLboolean _glewInit_GL_ARB_texture_multisample ()
 
 #ifdef GL_ARB_texture_storage
 
-static GLboolean _glewInit_GL_ARB_texture_storage ()
+static GLboolean _glewInit_GL_ARB_texture_storage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12683,7 +12975,7 @@ static GLboolean _glewInit_GL_ARB_texture_storage ()
 
 #ifdef GL_ARB_texture_storage_multisample
 
-static GLboolean _glewInit_GL_ARB_texture_storage_multisample ()
+static GLboolean _glewInit_GL_ARB_texture_storage_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12699,7 +12991,7 @@ static GLboolean _glewInit_GL_ARB_texture_storage_multisample ()
 
 #ifdef GL_ARB_texture_view
 
-static GLboolean _glewInit_GL_ARB_texture_view ()
+static GLboolean _glewInit_GL_ARB_texture_view (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12712,7 +13004,7 @@ static GLboolean _glewInit_GL_ARB_texture_view ()
 
 #ifdef GL_ARB_timer_query
 
-static GLboolean _glewInit_GL_ARB_timer_query ()
+static GLboolean _glewInit_GL_ARB_timer_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12727,7 +13019,7 @@ static GLboolean _glewInit_GL_ARB_timer_query ()
 
 #ifdef GL_ARB_transform_feedback2
 
-static GLboolean _glewInit_GL_ARB_transform_feedback2 ()
+static GLboolean _glewInit_GL_ARB_transform_feedback2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12746,7 +13038,7 @@ static GLboolean _glewInit_GL_ARB_transform_feedback2 ()
 
 #ifdef GL_ARB_transform_feedback3
 
-static GLboolean _glewInit_GL_ARB_transform_feedback3 ()
+static GLboolean _glewInit_GL_ARB_transform_feedback3 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12762,7 +13054,7 @@ static GLboolean _glewInit_GL_ARB_transform_feedback3 ()
 
 #ifdef GL_ARB_transform_feedback_instanced
 
-static GLboolean _glewInit_GL_ARB_transform_feedback_instanced ()
+static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12776,7 +13068,7 @@ static GLboolean _glewInit_GL_ARB_transform_feedback_instanced ()
 
 #ifdef GL_ARB_transpose_matrix
 
-static GLboolean _glewInit_GL_ARB_transpose_matrix ()
+static GLboolean _glewInit_GL_ARB_transpose_matrix (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12792,7 +13084,7 @@ static GLboolean _glewInit_GL_ARB_transpose_matrix ()
 
 #ifdef GL_ARB_uniform_buffer_object
 
-static GLboolean _glewInit_GL_ARB_uniform_buffer_object ()
+static GLboolean _glewInit_GL_ARB_uniform_buffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12814,7 +13106,7 @@ static GLboolean _glewInit_GL_ARB_uniform_buffer_object ()
 
 #ifdef GL_ARB_vertex_array_object
 
-static GLboolean _glewInit_GL_ARB_vertex_array_object ()
+static GLboolean _glewInit_GL_ARB_vertex_array_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12830,7 +13122,7 @@ static GLboolean _glewInit_GL_ARB_vertex_array_object ()
 
 #ifdef GL_ARB_vertex_attrib_64bit
 
-static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit ()
+static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12852,7 +13144,7 @@ static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit ()
 
 #ifdef GL_ARB_vertex_attrib_binding
 
-static GLboolean _glewInit_GL_ARB_vertex_attrib_binding ()
+static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12876,7 +13168,7 @@ static GLboolean _glewInit_GL_ARB_vertex_attrib_binding ()
 
 #ifdef GL_ARB_vertex_blend
 
-static GLboolean _glewInit_GL_ARB_vertex_blend ()
+static GLboolean _glewInit_GL_ARB_vertex_blend (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12898,7 +13190,7 @@ static GLboolean _glewInit_GL_ARB_vertex_blend ()
 
 #ifdef GL_ARB_vertex_buffer_object
 
-static GLboolean _glewInit_GL_ARB_vertex_buffer_object ()
+static GLboolean _glewInit_GL_ARB_vertex_buffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12921,7 +13213,7 @@ static GLboolean _glewInit_GL_ARB_vertex_buffer_object ()
 
 #ifdef GL_ARB_vertex_program
 
-static GLboolean _glewInit_GL_ARB_vertex_program ()
+static GLboolean _glewInit_GL_ARB_vertex_program (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -12995,7 +13287,7 @@ static GLboolean _glewInit_GL_ARB_vertex_program ()
 
 #ifdef GL_ARB_vertex_shader
 
-static GLboolean _glewInit_GL_ARB_vertex_shader ()
+static GLboolean _glewInit_GL_ARB_vertex_shader (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13010,7 +13302,7 @@ static GLboolean _glewInit_GL_ARB_vertex_shader ()
 
 #ifdef GL_ARB_vertex_type_2_10_10_10_rev
 
-static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev ()
+static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13060,7 +13352,7 @@ static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev ()
 
 #ifdef GL_ARB_viewport_array
 
-static GLboolean _glewInit_GL_ARB_viewport_array ()
+static GLboolean _glewInit_GL_ARB_viewport_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13082,7 +13374,7 @@ static GLboolean _glewInit_GL_ARB_viewport_array ()
 
 #ifdef GL_ARB_window_pos
 
-static GLboolean _glewInit_GL_ARB_window_pos ()
+static GLboolean _glewInit_GL_ARB_window_pos (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13108,9 +13400,22 @@ static GLboolean _glewInit_GL_ARB_window_pos ()
 
 #endif /* GL_ARB_window_pos */
 
+#ifdef GL_ARM_shader_core_properties
+
+static GLboolean _glewInit_GL_ARM_shader_core_properties (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glMaxActiveShaderCoresARM = (PFNGLMAXACTIVESHADERCORESARMPROC)glewGetProcAddress((const GLubyte*)"glMaxActiveShaderCoresARM")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_ARM_shader_core_properties */
+
 #ifdef GL_ATI_draw_buffers
 
-static GLboolean _glewInit_GL_ATI_draw_buffers ()
+static GLboolean _glewInit_GL_ATI_draw_buffers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13123,7 +13428,7 @@ static GLboolean _glewInit_GL_ATI_draw_buffers ()
 
 #ifdef GL_ATI_element_array
 
-static GLboolean _glewInit_GL_ATI_element_array ()
+static GLboolean _glewInit_GL_ATI_element_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13138,7 +13443,7 @@ static GLboolean _glewInit_GL_ATI_element_array ()
 
 #ifdef GL_ATI_envmap_bumpmap
 
-static GLboolean _glewInit_GL_ATI_envmap_bumpmap ()
+static GLboolean _glewInit_GL_ATI_envmap_bumpmap (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13154,7 +13459,7 @@ static GLboolean _glewInit_GL_ATI_envmap_bumpmap ()
 
 #ifdef GL_ATI_fragment_shader
 
-static GLboolean _glewInit_GL_ATI_fragment_shader ()
+static GLboolean _glewInit_GL_ATI_fragment_shader (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13180,7 +13485,7 @@ static GLboolean _glewInit_GL_ATI_fragment_shader ()
 
 #ifdef GL_ATI_map_object_buffer
 
-static GLboolean _glewInit_GL_ATI_map_object_buffer ()
+static GLboolean _glewInit_GL_ATI_map_object_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13194,7 +13499,7 @@ static GLboolean _glewInit_GL_ATI_map_object_buffer ()
 
 #ifdef GL_ATI_pn_triangles
 
-static GLboolean _glewInit_GL_ATI_pn_triangles ()
+static GLboolean _glewInit_GL_ATI_pn_triangles (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13208,7 +13513,7 @@ static GLboolean _glewInit_GL_ATI_pn_triangles ()
 
 #ifdef GL_ATI_separate_stencil
 
-static GLboolean _glewInit_GL_ATI_separate_stencil ()
+static GLboolean _glewInit_GL_ATI_separate_stencil (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13222,7 +13527,7 @@ static GLboolean _glewInit_GL_ATI_separate_stencil ()
 
 #ifdef GL_ATI_vertex_array_object
 
-static GLboolean _glewInit_GL_ATI_vertex_array_object ()
+static GLboolean _glewInit_GL_ATI_vertex_array_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13246,7 +13551,7 @@ static GLboolean _glewInit_GL_ATI_vertex_array_object ()
 
 #ifdef GL_ATI_vertex_attrib_array_object
 
-static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object ()
+static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13261,7 +13566,7 @@ static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object ()
 
 #ifdef GL_ATI_vertex_streams
 
-static GLboolean _glewInit_GL_ATI_vertex_streams ()
+static GLboolean _glewInit_GL_ATI_vertex_streams (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13318,7 +13623,7 @@ static GLboolean _glewInit_GL_ATI_vertex_streams ()
 
 #ifdef GL_EXT_EGL_image_storage
 
-static GLboolean _glewInit_GL_EXT_EGL_image_storage ()
+static GLboolean _glewInit_GL_EXT_EGL_image_storage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13332,7 +13637,7 @@ static GLboolean _glewInit_GL_EXT_EGL_image_storage ()
 
 #ifdef GL_EXT_base_instance
 
-static GLboolean _glewInit_GL_EXT_base_instance ()
+static GLboolean _glewInit_GL_EXT_base_instance (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13347,7 +13652,7 @@ static GLboolean _glewInit_GL_EXT_base_instance ()
 
 #ifdef GL_EXT_bindable_uniform
 
-static GLboolean _glewInit_GL_EXT_bindable_uniform ()
+static GLboolean _glewInit_GL_EXT_bindable_uniform (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13362,7 +13667,7 @@ static GLboolean _glewInit_GL_EXT_bindable_uniform ()
 
 #ifdef GL_EXT_blend_color
 
-static GLboolean _glewInit_GL_EXT_blend_color ()
+static GLboolean _glewInit_GL_EXT_blend_color (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13375,7 +13680,7 @@ static GLboolean _glewInit_GL_EXT_blend_color ()
 
 #ifdef GL_EXT_blend_equation_separate
 
-static GLboolean _glewInit_GL_EXT_blend_equation_separate ()
+static GLboolean _glewInit_GL_EXT_blend_equation_separate (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13388,7 +13693,7 @@ static GLboolean _glewInit_GL_EXT_blend_equation_separate ()
 
 #ifdef GL_EXT_blend_func_extended
 
-static GLboolean _glewInit_GL_EXT_blend_func_extended ()
+static GLboolean _glewInit_GL_EXT_blend_func_extended (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13403,7 +13708,7 @@ static GLboolean _glewInit_GL_EXT_blend_func_extended ()
 
 #ifdef GL_EXT_blend_func_separate
 
-static GLboolean _glewInit_GL_EXT_blend_func_separate ()
+static GLboolean _glewInit_GL_EXT_blend_func_separate (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13416,7 +13721,7 @@ static GLboolean _glewInit_GL_EXT_blend_func_separate ()
 
 #ifdef GL_EXT_blend_minmax
 
-static GLboolean _glewInit_GL_EXT_blend_minmax ()
+static GLboolean _glewInit_GL_EXT_blend_minmax (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13429,12 +13734,11 @@ static GLboolean _glewInit_GL_EXT_blend_minmax ()
 
 #ifdef GL_EXT_buffer_storage
 
-static GLboolean _glewInit_GL_EXT_buffer_storage ()
+static GLboolean _glewInit_GL_EXT_buffer_storage (void)
 {
   GLboolean r = GL_FALSE;
 
   r = ((glBufferStorageEXT = (PFNGLBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageEXT")) == NULL) || r;
-  r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r;
 
   return r;
 }
@@ -13443,7 +13747,7 @@ static GLboolean _glewInit_GL_EXT_buffer_storage ()
 
 #ifdef GL_EXT_clear_texture
 
-static GLboolean _glewInit_GL_EXT_clear_texture ()
+static GLboolean _glewInit_GL_EXT_clear_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13457,7 +13761,7 @@ static GLboolean _glewInit_GL_EXT_clear_texture ()
 
 #ifdef GL_EXT_clip_control
 
-static GLboolean _glewInit_GL_EXT_clip_control ()
+static GLboolean _glewInit_GL_EXT_clip_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13470,7 +13774,7 @@ static GLboolean _glewInit_GL_EXT_clip_control ()
 
 #ifdef GL_EXT_color_subtable
 
-static GLboolean _glewInit_GL_EXT_color_subtable ()
+static GLboolean _glewInit_GL_EXT_color_subtable (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13484,7 +13788,7 @@ static GLboolean _glewInit_GL_EXT_color_subtable ()
 
 #ifdef GL_EXT_compiled_vertex_array
 
-static GLboolean _glewInit_GL_EXT_compiled_vertex_array ()
+static GLboolean _glewInit_GL_EXT_compiled_vertex_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13498,7 +13802,7 @@ static GLboolean _glewInit_GL_EXT_compiled_vertex_array ()
 
 #ifdef GL_EXT_convolution
 
-static GLboolean _glewInit_GL_EXT_convolution ()
+static GLboolean _glewInit_GL_EXT_convolution (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13523,7 +13827,7 @@ static GLboolean _glewInit_GL_EXT_convolution ()
 
 #ifdef GL_EXT_coordinate_frame
 
-static GLboolean _glewInit_GL_EXT_coordinate_frame ()
+static GLboolean _glewInit_GL_EXT_coordinate_frame (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13537,7 +13841,7 @@ static GLboolean _glewInit_GL_EXT_coordinate_frame ()
 
 #ifdef GL_EXT_copy_image
 
-static GLboolean _glewInit_GL_EXT_copy_image ()
+static GLboolean _glewInit_GL_EXT_copy_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13550,7 +13854,7 @@ static GLboolean _glewInit_GL_EXT_copy_image ()
 
 #ifdef GL_EXT_copy_texture
 
-static GLboolean _glewInit_GL_EXT_copy_texture ()
+static GLboolean _glewInit_GL_EXT_copy_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13567,7 +13871,7 @@ static GLboolean _glewInit_GL_EXT_copy_texture ()
 
 #ifdef GL_EXT_cull_vertex
 
-static GLboolean _glewInit_GL_EXT_cull_vertex ()
+static GLboolean _glewInit_GL_EXT_cull_vertex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13581,7 +13885,7 @@ static GLboolean _glewInit_GL_EXT_cull_vertex ()
 
 #ifdef GL_EXT_debug_label
 
-static GLboolean _glewInit_GL_EXT_debug_label ()
+static GLboolean _glewInit_GL_EXT_debug_label (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13595,7 +13899,7 @@ static GLboolean _glewInit_GL_EXT_debug_label ()
 
 #ifdef GL_EXT_debug_marker
 
-static GLboolean _glewInit_GL_EXT_debug_marker ()
+static GLboolean _glewInit_GL_EXT_debug_marker (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13610,7 +13914,7 @@ static GLboolean _glewInit_GL_EXT_debug_marker ()
 
 #ifdef GL_EXT_depth_bounds_test
 
-static GLboolean _glewInit_GL_EXT_depth_bounds_test ()
+static GLboolean _glewInit_GL_EXT_depth_bounds_test (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13623,7 +13927,7 @@ static GLboolean _glewInit_GL_EXT_depth_bounds_test ()
 
 #ifdef GL_EXT_direct_state_access
 
-static GLboolean _glewInit_GL_EXT_direct_state_access ()
+static GLboolean _glewInit_GL_EXT_direct_state_access (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13756,6 +14060,7 @@ static GLboolean _glewInit_GL_EXT_direct_state_access ()
   r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r;
   r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r;
   r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r;
+  r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r;
   r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r;
   r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r;
   r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r;
@@ -13818,6 +14123,7 @@ static GLboolean _glewInit_GL_EXT_direct_state_access ()
   r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r;
   r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r;
   r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r;
+  r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r;
   r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r;
   r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r;
   r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r;
@@ -13849,7 +14155,7 @@ static GLboolean _glewInit_GL_EXT_direct_state_access ()
 
 #ifdef GL_EXT_discard_framebuffer
 
-static GLboolean _glewInit_GL_EXT_discard_framebuffer ()
+static GLboolean _glewInit_GL_EXT_discard_framebuffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13862,7 +14168,7 @@ static GLboolean _glewInit_GL_EXT_discard_framebuffer ()
 
 #ifdef GL_EXT_disjoint_timer_query
 
-static GLboolean _glewInit_GL_EXT_disjoint_timer_query ()
+static GLboolean _glewInit_GL_EXT_disjoint_timer_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13884,7 +14190,7 @@ static GLboolean _glewInit_GL_EXT_disjoint_timer_query ()
 
 #ifdef GL_EXT_draw_buffers
 
-static GLboolean _glewInit_GL_EXT_draw_buffers ()
+static GLboolean _glewInit_GL_EXT_draw_buffers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13897,7 +14203,7 @@ static GLboolean _glewInit_GL_EXT_draw_buffers ()
 
 #ifdef GL_EXT_draw_buffers2
 
-static GLboolean _glewInit_GL_EXT_draw_buffers2 ()
+static GLboolean _glewInit_GL_EXT_draw_buffers2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13915,7 +14221,7 @@ static GLboolean _glewInit_GL_EXT_draw_buffers2 ()
 
 #ifdef GL_EXT_draw_buffers_indexed
 
-static GLboolean _glewInit_GL_EXT_draw_buffers_indexed ()
+static GLboolean _glewInit_GL_EXT_draw_buffers_indexed (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13935,7 +14241,7 @@ static GLboolean _glewInit_GL_EXT_draw_buffers_indexed ()
 
 #ifdef GL_EXT_draw_elements_base_vertex
 
-static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex ()
+static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13951,7 +14257,7 @@ static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex ()
 
 #ifdef GL_EXT_draw_instanced
 
-static GLboolean _glewInit_GL_EXT_draw_instanced ()
+static GLboolean _glewInit_GL_EXT_draw_instanced (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13965,7 +14271,7 @@ static GLboolean _glewInit_GL_EXT_draw_instanced ()
 
 #ifdef GL_EXT_draw_range_elements
 
-static GLboolean _glewInit_GL_EXT_draw_range_elements ()
+static GLboolean _glewInit_GL_EXT_draw_range_elements (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13978,7 +14284,7 @@ static GLboolean _glewInit_GL_EXT_draw_range_elements ()
 
 #ifdef GL_EXT_draw_transform_feedback
 
-static GLboolean _glewInit_GL_EXT_draw_transform_feedback ()
+static GLboolean _glewInit_GL_EXT_draw_transform_feedback (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -13992,7 +14298,7 @@ static GLboolean _glewInit_GL_EXT_draw_transform_feedback ()
 
 #ifdef GL_EXT_external_buffer
 
-static GLboolean _glewInit_GL_EXT_external_buffer ()
+static GLboolean _glewInit_GL_EXT_external_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14006,7 +14312,7 @@ static GLboolean _glewInit_GL_EXT_external_buffer ()
 
 #ifdef GL_EXT_fog_coord
 
-static GLboolean _glewInit_GL_EXT_fog_coord ()
+static GLboolean _glewInit_GL_EXT_fog_coord (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14023,7 +14329,7 @@ static GLboolean _glewInit_GL_EXT_fog_coord ()
 
 #ifdef GL_EXT_fragment_lighting
 
-static GLboolean _glewInit_GL_EXT_fragment_lighting ()
+static GLboolean _glewInit_GL_EXT_fragment_lighting (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14051,9 +14357,25 @@ static GLboolean _glewInit_GL_EXT_fragment_lighting ()
 
 #endif /* GL_EXT_fragment_lighting */
 
+#ifdef GL_EXT_fragment_shading_rate
+
+static GLboolean _glewInit_GL_EXT_fragment_shading_rate (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glFramebufferShadingRateEXT = (PFNGLFRAMEBUFFERSHADINGRATEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferShadingRateEXT")) == NULL) || r;
+  r = ((glGetFragmentShadingRatesEXT = (PFNGLGETFRAGMENTSHADINGRATESEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentShadingRatesEXT")) == NULL) || r;
+  r = ((glShadingRateCombinerOpsEXT = (PFNGLSHADINGRATECOMBINEROPSEXTPROC)glewGetProcAddress((const GLubyte*)"glShadingRateCombinerOpsEXT")) == NULL) || r;
+  r = ((glShadingRateEXT = (PFNGLSHADINGRATEEXTPROC)glewGetProcAddress((const GLubyte*)"glShadingRateEXT")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_EXT_fragment_shading_rate */
+
 #ifdef GL_EXT_framebuffer_blit
 
-static GLboolean _glewInit_GL_EXT_framebuffer_blit ()
+static GLboolean _glewInit_GL_EXT_framebuffer_blit (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14064,9 +14386,23 @@ static GLboolean _glewInit_GL_EXT_framebuffer_blit ()
 
 #endif /* GL_EXT_framebuffer_blit */
 
+#ifdef GL_EXT_framebuffer_blit_layers
+
+static GLboolean _glewInit_GL_EXT_framebuffer_blit_layers (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glBlitFramebufferLayerEXT = (PFNGLBLITFRAMEBUFFERLAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferLayerEXT")) == NULL) || r;
+  r = ((glBlitFramebufferLayersEXT = (PFNGLBLITFRAMEBUFFERLAYERSEXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferLayersEXT")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_EXT_framebuffer_blit_layers */
+
 #ifdef GL_EXT_framebuffer_multisample
 
-static GLboolean _glewInit_GL_EXT_framebuffer_multisample ()
+static GLboolean _glewInit_GL_EXT_framebuffer_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14079,7 +14415,7 @@ static GLboolean _glewInit_GL_EXT_framebuffer_multisample ()
 
 #ifdef GL_EXT_framebuffer_object
 
-static GLboolean _glewInit_GL_EXT_framebuffer_object ()
+static GLboolean _glewInit_GL_EXT_framebuffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14108,7 +14444,7 @@ static GLboolean _glewInit_GL_EXT_framebuffer_object ()
 
 #ifdef GL_EXT_geometry_shader4
 
-static GLboolean _glewInit_GL_EXT_geometry_shader4 ()
+static GLboolean _glewInit_GL_EXT_geometry_shader4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14123,7 +14459,7 @@ static GLboolean _glewInit_GL_EXT_geometry_shader4 ()
 
 #ifdef GL_EXT_gpu_program_parameters
 
-static GLboolean _glewInit_GL_EXT_gpu_program_parameters ()
+static GLboolean _glewInit_GL_EXT_gpu_program_parameters (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14137,7 +14473,7 @@ static GLboolean _glewInit_GL_EXT_gpu_program_parameters ()
 
 #ifdef GL_EXT_gpu_shader4
 
-static GLboolean _glewInit_GL_EXT_gpu_shader4 ()
+static GLboolean _glewInit_GL_EXT_gpu_shader4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14183,7 +14519,7 @@ static GLboolean _glewInit_GL_EXT_gpu_shader4 ()
 
 #ifdef GL_EXT_histogram
 
-static GLboolean _glewInit_GL_EXT_histogram ()
+static GLboolean _glewInit_GL_EXT_histogram (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14205,7 +14541,7 @@ static GLboolean _glewInit_GL_EXT_histogram ()
 
 #ifdef GL_EXT_index_func
 
-static GLboolean _glewInit_GL_EXT_index_func ()
+static GLboolean _glewInit_GL_EXT_index_func (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14218,7 +14554,7 @@ static GLboolean _glewInit_GL_EXT_index_func ()
 
 #ifdef GL_EXT_index_material
 
-static GLboolean _glewInit_GL_EXT_index_material ()
+static GLboolean _glewInit_GL_EXT_index_material (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14231,7 +14567,7 @@ static GLboolean _glewInit_GL_EXT_index_material ()
 
 #ifdef GL_EXT_instanced_arrays
 
-static GLboolean _glewInit_GL_EXT_instanced_arrays ()
+static GLboolean _glewInit_GL_EXT_instanced_arrays (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14244,7 +14580,7 @@ static GLboolean _glewInit_GL_EXT_instanced_arrays ()
 
 #ifdef GL_EXT_light_texture
 
-static GLboolean _glewInit_GL_EXT_light_texture ()
+static GLboolean _glewInit_GL_EXT_light_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14259,7 +14595,7 @@ static GLboolean _glewInit_GL_EXT_light_texture ()
 
 #ifdef GL_EXT_map_buffer_range
 
-static GLboolean _glewInit_GL_EXT_map_buffer_range ()
+static GLboolean _glewInit_GL_EXT_map_buffer_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14273,7 +14609,7 @@ static GLboolean _glewInit_GL_EXT_map_buffer_range ()
 
 #ifdef GL_EXT_memory_object
 
-static GLboolean _glewInit_GL_EXT_memory_object ()
+static GLboolean _glewInit_GL_EXT_memory_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14304,7 +14640,7 @@ static GLboolean _glewInit_GL_EXT_memory_object ()
 
 #ifdef GL_EXT_memory_object_fd
 
-static GLboolean _glewInit_GL_EXT_memory_object_fd ()
+static GLboolean _glewInit_GL_EXT_memory_object_fd (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14317,7 +14653,7 @@ static GLboolean _glewInit_GL_EXT_memory_object_fd ()
 
 #ifdef GL_EXT_memory_object_win32
 
-static GLboolean _glewInit_GL_EXT_memory_object_win32 ()
+static GLboolean _glewInit_GL_EXT_memory_object_win32 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14329,9 +14665,25 @@ static GLboolean _glewInit_GL_EXT_memory_object_win32 ()
 
 #endif /* GL_EXT_memory_object_win32 */
 
+#ifdef GL_EXT_mesh_shader
+
+static GLboolean _glewInit_GL_EXT_mesh_shader (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glDrawMeshTasksEXT = (PFNGLDRAWMESHTASKSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawMeshTasksEXT")) == NULL) || r;
+  r = ((glDrawMeshTasksIndirectEXT = (PFNGLDRAWMESHTASKSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawMeshTasksIndirectEXT")) == NULL) || r;
+  r = ((glMultiDrawMeshTasksIndirectCountEXT = (PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawMeshTasksIndirectCountEXT")) == NULL) || r;
+  r = ((glMultiDrawMeshTasksIndirectEXT = (PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawMeshTasksIndirectEXT")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_EXT_mesh_shader */
+
 #ifdef GL_EXT_multi_draw_arrays
 
-static GLboolean _glewInit_GL_EXT_multi_draw_arrays ()
+static GLboolean _glewInit_GL_EXT_multi_draw_arrays (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14345,7 +14697,7 @@ static GLboolean _glewInit_GL_EXT_multi_draw_arrays ()
 
 #ifdef GL_EXT_multi_draw_indirect
 
-static GLboolean _glewInit_GL_EXT_multi_draw_indirect ()
+static GLboolean _glewInit_GL_EXT_multi_draw_indirect (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14359,7 +14711,7 @@ static GLboolean _glewInit_GL_EXT_multi_draw_indirect ()
 
 #ifdef GL_EXT_multisample
 
-static GLboolean _glewInit_GL_EXT_multisample ()
+static GLboolean _glewInit_GL_EXT_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14373,7 +14725,7 @@ static GLboolean _glewInit_GL_EXT_multisample ()
 
 #ifdef GL_EXT_multisampled_render_to_texture
 
-static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture ()
+static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14386,7 +14738,7 @@ static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture ()
 
 #ifdef GL_EXT_multiview_draw_buffers
 
-static GLboolean _glewInit_GL_EXT_multiview_draw_buffers ()
+static GLboolean _glewInit_GL_EXT_multiview_draw_buffers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14401,7 +14753,7 @@ static GLboolean _glewInit_GL_EXT_multiview_draw_buffers ()
 
 #ifdef GL_EXT_paletted_texture
 
-static GLboolean _glewInit_GL_EXT_paletted_texture ()
+static GLboolean _glewInit_GL_EXT_paletted_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14417,7 +14769,7 @@ static GLboolean _glewInit_GL_EXT_paletted_texture ()
 
 #ifdef GL_EXT_pixel_transform
 
-static GLboolean _glewInit_GL_EXT_pixel_transform ()
+static GLboolean _glewInit_GL_EXT_pixel_transform (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14435,7 +14787,7 @@ static GLboolean _glewInit_GL_EXT_pixel_transform ()
 
 #ifdef GL_EXT_point_parameters
 
-static GLboolean _glewInit_GL_EXT_point_parameters ()
+static GLboolean _glewInit_GL_EXT_point_parameters (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14449,7 +14801,7 @@ static GLboolean _glewInit_GL_EXT_point_parameters ()
 
 #ifdef GL_EXT_polygon_offset
 
-static GLboolean _glewInit_GL_EXT_polygon_offset ()
+static GLboolean _glewInit_GL_EXT_polygon_offset (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14462,7 +14814,7 @@ static GLboolean _glewInit_GL_EXT_polygon_offset ()
 
 #ifdef GL_EXT_polygon_offset_clamp
 
-static GLboolean _glewInit_GL_EXT_polygon_offset_clamp ()
+static GLboolean _glewInit_GL_EXT_polygon_offset_clamp (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14475,7 +14827,7 @@ static GLboolean _glewInit_GL_EXT_polygon_offset_clamp ()
 
 #ifdef GL_EXT_primitive_bounding_box
 
-static GLboolean _glewInit_GL_EXT_primitive_bounding_box ()
+static GLboolean _glewInit_GL_EXT_primitive_bounding_box (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14488,7 +14840,7 @@ static GLboolean _glewInit_GL_EXT_primitive_bounding_box ()
 
 #ifdef GL_EXT_provoking_vertex
 
-static GLboolean _glewInit_GL_EXT_provoking_vertex ()
+static GLboolean _glewInit_GL_EXT_provoking_vertex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14501,7 +14853,7 @@ static GLboolean _glewInit_GL_EXT_provoking_vertex ()
 
 #ifdef GL_EXT_raster_multisample
 
-static GLboolean _glewInit_GL_EXT_raster_multisample ()
+static GLboolean _glewInit_GL_EXT_raster_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14517,10 +14869,11 @@ static GLboolean _glewInit_GL_EXT_raster_multisample ()
 
 #ifdef GL_EXT_robustness
 
-static GLboolean _glewInit_GL_EXT_robustness ()
+static GLboolean _glewInit_GL_EXT_robustness (void)
 {
   GLboolean r = GL_FALSE;
 
+  r = ((glGetGraphicsResetStatusEXT = (PFNGLGETGRAPHICSRESETSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusEXT")) == NULL) || r;
   r = ((glGetnUniformfvEXT = (PFNGLGETNUNIFORMFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvEXT")) == NULL) || r;
   r = ((glGetnUniformivEXT = (PFNGLGETNUNIFORMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivEXT")) == NULL) || r;
   r = ((glReadnPixelsEXT = (PFNGLREADNPIXELSEXTPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsEXT")) == NULL) || r;
@@ -14532,7 +14885,7 @@ static GLboolean _glewInit_GL_EXT_robustness ()
 
 #ifdef GL_EXT_scene_marker
 
-static GLboolean _glewInit_GL_EXT_scene_marker ()
+static GLboolean _glewInit_GL_EXT_scene_marker (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14546,7 +14899,7 @@ static GLboolean _glewInit_GL_EXT_scene_marker ()
 
 #ifdef GL_EXT_secondary_color
 
-static GLboolean _glewInit_GL_EXT_secondary_color ()
+static GLboolean _glewInit_GL_EXT_secondary_color (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14575,7 +14928,7 @@ static GLboolean _glewInit_GL_EXT_secondary_color ()
 
 #ifdef GL_EXT_semaphore
 
-static GLboolean _glewInit_GL_EXT_semaphore ()
+static GLboolean _glewInit_GL_EXT_semaphore (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14594,7 +14947,7 @@ static GLboolean _glewInit_GL_EXT_semaphore ()
 
 #ifdef GL_EXT_semaphore_fd
 
-static GLboolean _glewInit_GL_EXT_semaphore_fd ()
+static GLboolean _glewInit_GL_EXT_semaphore_fd (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14607,7 +14960,7 @@ static GLboolean _glewInit_GL_EXT_semaphore_fd ()
 
 #ifdef GL_EXT_semaphore_win32
 
-static GLboolean _glewInit_GL_EXT_semaphore_win32 ()
+static GLboolean _glewInit_GL_EXT_semaphore_win32 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14621,7 +14974,7 @@ static GLboolean _glewInit_GL_EXT_semaphore_win32 ()
 
 #ifdef GL_EXT_separate_shader_objects
 
-static GLboolean _glewInit_GL_EXT_separate_shader_objects ()
+static GLboolean _glewInit_GL_EXT_separate_shader_objects (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14636,7 +14989,7 @@ static GLboolean _glewInit_GL_EXT_separate_shader_objects ()
 
 #ifdef GL_EXT_shader_framebuffer_fetch
 
-static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch ()
+static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14649,7 +15002,7 @@ static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch ()
 
 #ifdef GL_EXT_shader_image_load_store
 
-static GLboolean _glewInit_GL_EXT_shader_image_load_store ()
+static GLboolean _glewInit_GL_EXT_shader_image_load_store (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14663,7 +15016,7 @@ static GLboolean _glewInit_GL_EXT_shader_image_load_store ()
 
 #ifdef GL_EXT_shader_pixel_local_storage2
 
-static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 ()
+static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14678,12 +15031,11 @@ static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 ()
 
 #ifdef GL_EXT_sparse_texture
 
-static GLboolean _glewInit_GL_EXT_sparse_texture ()
+static GLboolean _glewInit_GL_EXT_sparse_texture (void)
 {
   GLboolean r = GL_FALSE;
 
   r = ((glTexPageCommitmentEXT = (PFNGLTEXPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentEXT")) == NULL) || r;
-  r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r;
 
   return r;
 }
@@ -14692,7 +15044,7 @@ static GLboolean _glewInit_GL_EXT_sparse_texture ()
 
 #ifdef GL_EXT_stencil_two_side
 
-static GLboolean _glewInit_GL_EXT_stencil_two_side ()
+static GLboolean _glewInit_GL_EXT_stencil_two_side (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14705,7 +15057,7 @@ static GLboolean _glewInit_GL_EXT_stencil_two_side ()
 
 #ifdef GL_EXT_subtexture
 
-static GLboolean _glewInit_GL_EXT_subtexture ()
+static GLboolean _glewInit_GL_EXT_subtexture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14720,7 +15072,7 @@ static GLboolean _glewInit_GL_EXT_subtexture ()
 
 #ifdef GL_EXT_tessellation_point_size
 
-static GLboolean _glewInit_GL_EXT_tessellation_point_size ()
+static GLboolean _glewInit_GL_EXT_tessellation_point_size (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14733,7 +15085,7 @@ static GLboolean _glewInit_GL_EXT_tessellation_point_size ()
 
 #ifdef GL_EXT_texture3D
 
-static GLboolean _glewInit_GL_EXT_texture3D ()
+static GLboolean _glewInit_GL_EXT_texture3D (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14746,7 +15098,7 @@ static GLboolean _glewInit_GL_EXT_texture3D ()
 
 #ifdef GL_EXT_texture_array
 
-static GLboolean _glewInit_GL_EXT_texture_array ()
+static GLboolean _glewInit_GL_EXT_texture_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14759,7 +15111,7 @@ static GLboolean _glewInit_GL_EXT_texture_array ()
 
 #ifdef GL_EXT_texture_border_clamp
 
-static GLboolean _glewInit_GL_EXT_texture_border_clamp ()
+static GLboolean _glewInit_GL_EXT_texture_border_clamp (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14775,7 +15127,7 @@ static GLboolean _glewInit_GL_EXT_texture_border_clamp ()
 
 #ifdef GL_EXT_texture_buffer_object
 
-static GLboolean _glewInit_GL_EXT_texture_buffer_object ()
+static GLboolean _glewInit_GL_EXT_texture_buffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14788,7 +15140,7 @@ static GLboolean _glewInit_GL_EXT_texture_buffer_object ()
 
 #ifdef GL_EXT_texture_integer
 
-static GLboolean _glewInit_GL_EXT_texture_integer ()
+static GLboolean _glewInit_GL_EXT_texture_integer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14806,7 +15158,7 @@ static GLboolean _glewInit_GL_EXT_texture_integer ()
 
 #ifdef GL_EXT_texture_object
 
-static GLboolean _glewInit_GL_EXT_texture_object ()
+static GLboolean _glewInit_GL_EXT_texture_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14824,7 +15176,7 @@ static GLboolean _glewInit_GL_EXT_texture_object ()
 
 #ifdef GL_EXT_texture_perturb_normal
 
-static GLboolean _glewInit_GL_EXT_texture_perturb_normal ()
+static GLboolean _glewInit_GL_EXT_texture_perturb_normal (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14837,7 +15189,7 @@ static GLboolean _glewInit_GL_EXT_texture_perturb_normal ()
 
 #ifdef GL_EXT_texture_storage
 
-static GLboolean _glewInit_GL_EXT_texture_storage ()
+static GLboolean _glewInit_GL_EXT_texture_storage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14853,9 +15205,23 @@ static GLboolean _glewInit_GL_EXT_texture_storage ()
 
 #endif /* GL_EXT_texture_storage */
 
+#ifdef GL_EXT_texture_storage_compression
+
+static GLboolean _glewInit_GL_EXT_texture_storage_compression (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glTexStorageAttribs2DEXT = (PFNGLTEXSTORAGEATTRIBS2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageAttribs2DEXT")) == NULL) || r;
+  r = ((glTexStorageAttribs3DEXT = (PFNGLTEXSTORAGEATTRIBS3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageAttribs3DEXT")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_EXT_texture_storage_compression */
+
 #ifdef GL_EXT_texture_view
 
-static GLboolean _glewInit_GL_EXT_texture_view ()
+static GLboolean _glewInit_GL_EXT_texture_view (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14868,7 +15234,7 @@ static GLboolean _glewInit_GL_EXT_texture_view ()
 
 #ifdef GL_EXT_timer_query
 
-static GLboolean _glewInit_GL_EXT_timer_query ()
+static GLboolean _glewInit_GL_EXT_timer_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14882,7 +15248,7 @@ static GLboolean _glewInit_GL_EXT_timer_query ()
 
 #ifdef GL_EXT_transform_feedback
 
-static GLboolean _glewInit_GL_EXT_transform_feedback ()
+static GLboolean _glewInit_GL_EXT_transform_feedback (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14901,7 +15267,7 @@ static GLboolean _glewInit_GL_EXT_transform_feedback ()
 
 #ifdef GL_EXT_vertex_array
 
-static GLboolean _glewInit_GL_EXT_vertex_array ()
+static GLboolean _glewInit_GL_EXT_vertex_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14921,7 +15287,7 @@ static GLboolean _glewInit_GL_EXT_vertex_array ()
 
 #ifdef GL_EXT_vertex_array_setXXX
 
-static GLboolean _glewInit_GL_EXT_vertex_array_setXXX ()
+static GLboolean _glewInit_GL_EXT_vertex_array_setXXX (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14936,7 +15302,7 @@ static GLboolean _glewInit_GL_EXT_vertex_array_setXXX ()
 
 #ifdef GL_EXT_vertex_attrib_64bit
 
-static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit ()
+static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -14959,7 +15325,7 @@ static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit ()
 
 #ifdef GL_EXT_vertex_shader
 
-static GLboolean _glewInit_GL_EXT_vertex_shader ()
+static GLboolean _glewInit_GL_EXT_vertex_shader (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15013,7 +15379,7 @@ static GLboolean _glewInit_GL_EXT_vertex_shader ()
 
 #ifdef GL_EXT_vertex_weighting
 
-static GLboolean _glewInit_GL_EXT_vertex_weighting ()
+static GLboolean _glewInit_GL_EXT_vertex_weighting (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15028,7 +15394,7 @@ static GLboolean _glewInit_GL_EXT_vertex_weighting ()
 
 #ifdef GL_EXT_win32_keyed_mutex
 
-static GLboolean _glewInit_GL_EXT_win32_keyed_mutex ()
+static GLboolean _glewInit_GL_EXT_win32_keyed_mutex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15042,7 +15408,7 @@ static GLboolean _glewInit_GL_EXT_win32_keyed_mutex ()
 
 #ifdef GL_EXT_window_rectangles
 
-static GLboolean _glewInit_GL_EXT_window_rectangles ()
+static GLboolean _glewInit_GL_EXT_window_rectangles (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15055,7 +15421,7 @@ static GLboolean _glewInit_GL_EXT_window_rectangles ()
 
 #ifdef GL_EXT_x11_sync_object
 
-static GLboolean _glewInit_GL_EXT_x11_sync_object ()
+static GLboolean _glewInit_GL_EXT_x11_sync_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15068,7 +15434,7 @@ static GLboolean _glewInit_GL_EXT_x11_sync_object ()
 
 #ifdef GL_GREMEDY_frame_terminator
 
-static GLboolean _glewInit_GL_GREMEDY_frame_terminator ()
+static GLboolean _glewInit_GL_GREMEDY_frame_terminator (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15081,7 +15447,7 @@ static GLboolean _glewInit_GL_GREMEDY_frame_terminator ()
 
 #ifdef GL_GREMEDY_string_marker
 
-static GLboolean _glewInit_GL_GREMEDY_string_marker ()
+static GLboolean _glewInit_GL_GREMEDY_string_marker (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15094,7 +15460,7 @@ static GLboolean _glewInit_GL_GREMEDY_string_marker ()
 
 #ifdef GL_HP_image_transform
 
-static GLboolean _glewInit_GL_HP_image_transform ()
+static GLboolean _glewInit_GL_HP_image_transform (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15112,7 +15478,7 @@ static GLboolean _glewInit_GL_HP_image_transform ()
 
 #ifdef GL_IBM_multimode_draw_arrays
 
-static GLboolean _glewInit_GL_IBM_multimode_draw_arrays ()
+static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15126,7 +15492,7 @@ static GLboolean _glewInit_GL_IBM_multimode_draw_arrays ()
 
 #ifdef GL_IBM_vertex_array_lists
 
-static GLboolean _glewInit_GL_IBM_vertex_array_lists ()
+static GLboolean _glewInit_GL_IBM_vertex_array_lists (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15146,7 +15512,7 @@ static GLboolean _glewInit_GL_IBM_vertex_array_lists ()
 
 #ifdef GL_IMG_bindless_texture
 
-static GLboolean _glewInit_GL_IMG_bindless_texture ()
+static GLboolean _glewInit_GL_IMG_bindless_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15164,7 +15530,7 @@ static GLboolean _glewInit_GL_IMG_bindless_texture ()
 
 #ifdef GL_IMG_framebuffer_downsample
 
-static GLboolean _glewInit_GL_IMG_framebuffer_downsample ()
+static GLboolean _glewInit_GL_IMG_framebuffer_downsample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15178,7 +15544,7 @@ static GLboolean _glewInit_GL_IMG_framebuffer_downsample ()
 
 #ifdef GL_IMG_multisampled_render_to_texture
 
-static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture ()
+static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15190,9 +15556,22 @@ static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture ()
 
 #endif /* GL_IMG_multisampled_render_to_texture */
 
+#ifdef GL_INTEL_framebuffer_CMAA
+
+static GLboolean _glewInit_GL_INTEL_framebuffer_CMAA (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glApplyFramebufferAttachmentCMAAINTEL = (PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC)glewGetProcAddress((const GLubyte*)"glApplyFramebufferAttachmentCMAAINTEL")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_INTEL_framebuffer_CMAA */
+
 #ifdef GL_INTEL_map_texture
 
-static GLboolean _glewInit_GL_INTEL_map_texture ()
+static GLboolean _glewInit_GL_INTEL_map_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15207,7 +15586,7 @@ static GLboolean _glewInit_GL_INTEL_map_texture ()
 
 #ifdef GL_INTEL_parallel_arrays
 
-static GLboolean _glewInit_GL_INTEL_parallel_arrays ()
+static GLboolean _glewInit_GL_INTEL_parallel_arrays (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15223,7 +15602,7 @@ static GLboolean _glewInit_GL_INTEL_parallel_arrays ()
 
 #ifdef GL_INTEL_performance_query
 
-static GLboolean _glewInit_GL_INTEL_performance_query ()
+static GLboolean _glewInit_GL_INTEL_performance_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15245,7 +15624,7 @@ static GLboolean _glewInit_GL_INTEL_performance_query ()
 
 #ifdef GL_INTEL_texture_scissor
 
-static GLboolean _glewInit_GL_INTEL_texture_scissor ()
+static GLboolean _glewInit_GL_INTEL_texture_scissor (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15259,7 +15638,7 @@ static GLboolean _glewInit_GL_INTEL_texture_scissor ()
 
 #ifdef GL_KHR_blend_equation_advanced
 
-static GLboolean _glewInit_GL_KHR_blend_equation_advanced ()
+static GLboolean _glewInit_GL_KHR_blend_equation_advanced (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15272,7 +15651,7 @@ static GLboolean _glewInit_GL_KHR_blend_equation_advanced ()
 
 #ifdef GL_KHR_debug
 
-static GLboolean _glewInit_GL_KHR_debug ()
+static GLboolean _glewInit_GL_KHR_debug (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15294,7 +15673,7 @@ static GLboolean _glewInit_GL_KHR_debug ()
 
 #ifdef GL_KHR_parallel_shader_compile
 
-static GLboolean _glewInit_GL_KHR_parallel_shader_compile ()
+static GLboolean _glewInit_GL_KHR_parallel_shader_compile (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15307,7 +15686,7 @@ static GLboolean _glewInit_GL_KHR_parallel_shader_compile ()
 
 #ifdef GL_KHR_robustness
 
-static GLboolean _glewInit_GL_KHR_robustness ()
+static GLboolean _glewInit_GL_KHR_robustness (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15323,7 +15702,7 @@ static GLboolean _glewInit_GL_KHR_robustness ()
 
 #ifdef GL_KTX_buffer_region
 
-static GLboolean _glewInit_GL_KTX_buffer_region ()
+static GLboolean _glewInit_GL_KTX_buffer_region (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15340,7 +15719,7 @@ static GLboolean _glewInit_GL_KTX_buffer_region ()
 
 #ifdef GL_MESA_framebuffer_flip_y
 
-static GLboolean _glewInit_GL_MESA_framebuffer_flip_y ()
+static GLboolean _glewInit_GL_MESA_framebuffer_flip_y (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15354,7 +15733,7 @@ static GLboolean _glewInit_GL_MESA_framebuffer_flip_y ()
 
 #ifdef GL_MESA_resize_buffers
 
-static GLboolean _glewInit_GL_MESA_resize_buffers ()
+static GLboolean _glewInit_GL_MESA_resize_buffers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15367,7 +15746,7 @@ static GLboolean _glewInit_GL_MESA_resize_buffers ()
 
 #ifdef GL_MESA_window_pos
 
-static GLboolean _glewInit_GL_MESA_window_pos ()
+static GLboolean _glewInit_GL_MESA_window_pos (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15403,7 +15782,7 @@ static GLboolean _glewInit_GL_MESA_window_pos ()
 
 #ifdef GL_NVX_conditional_render
 
-static GLboolean _glewInit_GL_NVX_conditional_render ()
+static GLboolean _glewInit_GL_NVX_conditional_render (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15417,7 +15796,7 @@ static GLboolean _glewInit_GL_NVX_conditional_render ()
 
 #ifdef GL_NVX_gpu_multicast2
 
-static GLboolean _glewInit_GL_NVX_gpu_multicast2 ()
+static GLboolean _glewInit_GL_NVX_gpu_multicast2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15435,7 +15814,7 @@ static GLboolean _glewInit_GL_NVX_gpu_multicast2 ()
 
 #ifdef GL_NVX_linked_gpu_multicast
 
-static GLboolean _glewInit_GL_NVX_linked_gpu_multicast ()
+static GLboolean _glewInit_GL_NVX_linked_gpu_multicast (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15450,11 +15829,12 @@ static GLboolean _glewInit_GL_NVX_linked_gpu_multicast ()
 
 #ifdef GL_NVX_progress_fence
 
-static GLboolean _glewInit_GL_NVX_progress_fence ()
+static GLboolean _glewInit_GL_NVX_progress_fence (void)
 {
   GLboolean r = GL_FALSE;
 
   r = ((glClientWaitSemaphoreui64NVX = (PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSemaphoreui64NVX")) == NULL) || r;
+  r = ((glCreateProgressFenceNVX = (PFNGLCREATEPROGRESSFENCENVXPROC)glewGetProcAddress((const GLubyte*)"glCreateProgressFenceNVX")) == NULL) || r;
   r = ((glSignalSemaphoreui64NVX = (PFNGLSIGNALSEMAPHOREUI64NVXPROC)glewGetProcAddress((const GLubyte*)"glSignalSemaphoreui64NVX")) == NULL) || r;
   r = ((glWaitSemaphoreui64NVX = (PFNGLWAITSEMAPHOREUI64NVXPROC)glewGetProcAddress((const GLubyte*)"glWaitSemaphoreui64NVX")) == NULL) || r;
 
@@ -15465,7 +15845,7 @@ static GLboolean _glewInit_GL_NVX_progress_fence ()
 
 #ifdef GL_NV_3dvision_settings
 
-static GLboolean _glewInit_GL_NV_3dvision_settings ()
+static GLboolean _glewInit_GL_NV_3dvision_settings (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15479,7 +15859,7 @@ static GLboolean _glewInit_GL_NV_3dvision_settings ()
 
 #ifdef GL_NV_alpha_to_coverage_dither_control
 
-static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control ()
+static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15492,7 +15872,7 @@ static GLboolean _glewInit_GL_NV_alpha_to_coverage_dither_control ()
 
 #ifdef GL_NV_bindless_multi_draw_indirect
 
-static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect ()
+static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15506,7 +15886,7 @@ static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect ()
 
 #ifdef GL_NV_bindless_multi_draw_indirect_count
 
-static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count ()
+static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15520,7 +15900,7 @@ static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count ()
 
 #ifdef GL_NV_bindless_texture
 
-static GLboolean _glewInit_GL_NV_bindless_texture ()
+static GLboolean _glewInit_GL_NV_bindless_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15545,7 +15925,7 @@ static GLboolean _glewInit_GL_NV_bindless_texture ()
 
 #ifdef GL_NV_blend_equation_advanced
 
-static GLboolean _glewInit_GL_NV_blend_equation_advanced ()
+static GLboolean _glewInit_GL_NV_blend_equation_advanced (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15559,7 +15939,7 @@ static GLboolean _glewInit_GL_NV_blend_equation_advanced ()
 
 #ifdef GL_NV_clip_space_w_scaling
 
-static GLboolean _glewInit_GL_NV_clip_space_w_scaling ()
+static GLboolean _glewInit_GL_NV_clip_space_w_scaling (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15572,7 +15952,7 @@ static GLboolean _glewInit_GL_NV_clip_space_w_scaling ()
 
 #ifdef GL_NV_command_list
 
-static GLboolean _glewInit_GL_NV_command_list ()
+static GLboolean _glewInit_GL_NV_command_list (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15601,7 +15981,7 @@ static GLboolean _glewInit_GL_NV_command_list ()
 
 #ifdef GL_NV_conditional_render
 
-static GLboolean _glewInit_GL_NV_conditional_render ()
+static GLboolean _glewInit_GL_NV_conditional_render (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15615,7 +15995,7 @@ static GLboolean _glewInit_GL_NV_conditional_render ()
 
 #ifdef GL_NV_conservative_raster
 
-static GLboolean _glewInit_GL_NV_conservative_raster ()
+static GLboolean _glewInit_GL_NV_conservative_raster (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15628,7 +16008,7 @@ static GLboolean _glewInit_GL_NV_conservative_raster ()
 
 #ifdef GL_NV_conservative_raster_dilate
 
-static GLboolean _glewInit_GL_NV_conservative_raster_dilate ()
+static GLboolean _glewInit_GL_NV_conservative_raster_dilate (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15641,7 +16021,7 @@ static GLboolean _glewInit_GL_NV_conservative_raster_dilate ()
 
 #ifdef GL_NV_conservative_raster_pre_snap_triangles
 
-static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles ()
+static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15654,7 +16034,7 @@ static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles ()
 
 #ifdef GL_NV_copy_buffer
 
-static GLboolean _glewInit_GL_NV_copy_buffer ()
+static GLboolean _glewInit_GL_NV_copy_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15667,7 +16047,7 @@ static GLboolean _glewInit_GL_NV_copy_buffer ()
 
 #ifdef GL_NV_copy_image
 
-static GLboolean _glewInit_GL_NV_copy_image ()
+static GLboolean _glewInit_GL_NV_copy_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15680,7 +16060,7 @@ static GLboolean _glewInit_GL_NV_copy_image ()
 
 #ifdef GL_NV_depth_buffer_float
 
-static GLboolean _glewInit_GL_NV_depth_buffer_float ()
+static GLboolean _glewInit_GL_NV_depth_buffer_float (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15695,7 +16075,7 @@ static GLboolean _glewInit_GL_NV_depth_buffer_float ()
 
 #ifdef GL_NV_draw_buffers
 
-static GLboolean _glewInit_GL_NV_draw_buffers ()
+static GLboolean _glewInit_GL_NV_draw_buffers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15708,7 +16088,7 @@ static GLboolean _glewInit_GL_NV_draw_buffers ()
 
 #ifdef GL_NV_draw_instanced
 
-static GLboolean _glewInit_GL_NV_draw_instanced ()
+static GLboolean _glewInit_GL_NV_draw_instanced (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15722,7 +16102,7 @@ static GLboolean _glewInit_GL_NV_draw_instanced ()
 
 #ifdef GL_NV_draw_texture
 
-static GLboolean _glewInit_GL_NV_draw_texture ()
+static GLboolean _glewInit_GL_NV_draw_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15735,7 +16115,7 @@ static GLboolean _glewInit_GL_NV_draw_texture ()
 
 #ifdef GL_NV_draw_vulkan_image
 
-static GLboolean _glewInit_GL_NV_draw_vulkan_image ()
+static GLboolean _glewInit_GL_NV_draw_vulkan_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15752,7 +16132,7 @@ static GLboolean _glewInit_GL_NV_draw_vulkan_image ()
 
 #ifdef GL_NV_evaluators
 
-static GLboolean _glewInit_GL_NV_evaluators ()
+static GLboolean _glewInit_GL_NV_evaluators (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15773,7 +16153,7 @@ static GLboolean _glewInit_GL_NV_evaluators ()
 
 #ifdef GL_NV_explicit_multisample
 
-static GLboolean _glewInit_GL_NV_explicit_multisample ()
+static GLboolean _glewInit_GL_NV_explicit_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15788,7 +16168,7 @@ static GLboolean _glewInit_GL_NV_explicit_multisample ()
 
 #ifdef GL_NV_fence
 
-static GLboolean _glewInit_GL_NV_fence ()
+static GLboolean _glewInit_GL_NV_fence (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15807,7 +16187,7 @@ static GLboolean _glewInit_GL_NV_fence ()
 
 #ifdef GL_NV_fragment_coverage_to_color
 
-static GLboolean _glewInit_GL_NV_fragment_coverage_to_color ()
+static GLboolean _glewInit_GL_NV_fragment_coverage_to_color (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15820,7 +16200,7 @@ static GLboolean _glewInit_GL_NV_fragment_coverage_to_color ()
 
 #ifdef GL_NV_fragment_program
 
-static GLboolean _glewInit_GL_NV_fragment_program ()
+static GLboolean _glewInit_GL_NV_fragment_program (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15838,7 +16218,7 @@ static GLboolean _glewInit_GL_NV_fragment_program ()
 
 #ifdef GL_NV_framebuffer_blit
 
-static GLboolean _glewInit_GL_NV_framebuffer_blit ()
+static GLboolean _glewInit_GL_NV_framebuffer_blit (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15851,7 +16231,7 @@ static GLboolean _glewInit_GL_NV_framebuffer_blit ()
 
 #ifdef GL_NV_framebuffer_multisample
 
-static GLboolean _glewInit_GL_NV_framebuffer_multisample ()
+static GLboolean _glewInit_GL_NV_framebuffer_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15864,7 +16244,7 @@ static GLboolean _glewInit_GL_NV_framebuffer_multisample ()
 
 #ifdef GL_NV_framebuffer_multisample_coverage
 
-static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage ()
+static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15877,7 +16257,7 @@ static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage ()
 
 #ifdef GL_NV_geometry_program4
 
-static GLboolean _glewInit_GL_NV_geometry_program4 ()
+static GLboolean _glewInit_GL_NV_geometry_program4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15890,7 +16270,7 @@ static GLboolean _glewInit_GL_NV_geometry_program4 ()
 
 #ifdef GL_NV_gpu_multicast
 
-static GLboolean _glewInit_GL_NV_gpu_multicast ()
+static GLboolean _glewInit_GL_NV_gpu_multicast (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15914,7 +16294,7 @@ static GLboolean _glewInit_GL_NV_gpu_multicast ()
 
 #ifdef GL_NV_gpu_program4
 
-static GLboolean _glewInit_GL_NV_gpu_program4 ()
+static GLboolean _glewInit_GL_NV_gpu_program4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15938,7 +16318,7 @@ static GLboolean _glewInit_GL_NV_gpu_program4 ()
 
 #ifdef GL_NV_gpu_shader5
 
-static GLboolean _glewInit_GL_NV_gpu_shader5 ()
+static GLboolean _glewInit_GL_NV_gpu_shader5 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -15984,7 +16364,7 @@ static GLboolean _glewInit_GL_NV_gpu_shader5 ()
 
 #ifdef GL_NV_half_float
 
-static GLboolean _glewInit_GL_NV_half_float ()
+static GLboolean _glewInit_GL_NV_half_float (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16042,7 +16422,7 @@ static GLboolean _glewInit_GL_NV_half_float ()
 
 #ifdef GL_NV_instanced_arrays
 
-static GLboolean _glewInit_GL_NV_instanced_arrays ()
+static GLboolean _glewInit_GL_NV_instanced_arrays (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16055,7 +16435,7 @@ static GLboolean _glewInit_GL_NV_instanced_arrays ()
 
 #ifdef GL_NV_internalformat_sample_query
 
-static GLboolean _glewInit_GL_NV_internalformat_sample_query ()
+static GLboolean _glewInit_GL_NV_internalformat_sample_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16068,7 +16448,7 @@ static GLboolean _glewInit_GL_NV_internalformat_sample_query ()
 
 #ifdef GL_NV_memory_attachment
 
-static GLboolean _glewInit_GL_NV_memory_attachment ()
+static GLboolean _glewInit_GL_NV_memory_attachment (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16084,9 +16464,25 @@ static GLboolean _glewInit_GL_NV_memory_attachment ()
 
 #endif /* GL_NV_memory_attachment */
 
+#ifdef GL_NV_memory_object_sparse
+
+static GLboolean _glewInit_GL_NV_memory_object_sparse (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glBufferPageCommitmentMemNV = (PFNGLBUFFERPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glBufferPageCommitmentMemNV")) == NULL) || r;
+  r = ((glNamedBufferPageCommitmentMemNV = (PFNGLNAMEDBUFFERPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferPageCommitmentMemNV")) == NULL) || r;
+  r = ((glTexPageCommitmentMemNV = (PFNGLTEXPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentMemNV")) == NULL) || r;
+  r = ((glTexturePageCommitmentMemNV = (PFNGLTEXTUREPAGECOMMITMENTMEMNVPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentMemNV")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_NV_memory_object_sparse */
+
 #ifdef GL_NV_mesh_shader
 
-static GLboolean _glewInit_GL_NV_mesh_shader ()
+static GLboolean _glewInit_GL_NV_mesh_shader (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16102,7 +16498,7 @@ static GLboolean _glewInit_GL_NV_mesh_shader ()
 
 #ifdef GL_NV_non_square_matrices
 
-static GLboolean _glewInit_GL_NV_non_square_matrices ()
+static GLboolean _glewInit_GL_NV_non_square_matrices (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16120,7 +16516,7 @@ static GLboolean _glewInit_GL_NV_non_square_matrices ()
 
 #ifdef GL_NV_occlusion_query
 
-static GLboolean _glewInit_GL_NV_occlusion_query ()
+static GLboolean _glewInit_GL_NV_occlusion_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16139,7 +16535,7 @@ static GLboolean _glewInit_GL_NV_occlusion_query ()
 
 #ifdef GL_NV_parameter_buffer_object
 
-static GLboolean _glewInit_GL_NV_parameter_buffer_object ()
+static GLboolean _glewInit_GL_NV_parameter_buffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16154,7 +16550,7 @@ static GLboolean _glewInit_GL_NV_parameter_buffer_object ()
 
 #ifdef GL_NV_path_rendering
 
-static GLboolean _glewInit_GL_NV_path_rendering ()
+static GLboolean _glewInit_GL_NV_path_rendering (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16230,7 +16626,7 @@ static GLboolean _glewInit_GL_NV_path_rendering ()
 
 #ifdef GL_NV_pixel_data_range
 
-static GLboolean _glewInit_GL_NV_pixel_data_range ()
+static GLboolean _glewInit_GL_NV_pixel_data_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16244,7 +16640,7 @@ static GLboolean _glewInit_GL_NV_pixel_data_range ()
 
 #ifdef GL_NV_point_sprite
 
-static GLboolean _glewInit_GL_NV_point_sprite ()
+static GLboolean _glewInit_GL_NV_point_sprite (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16258,7 +16654,7 @@ static GLboolean _glewInit_GL_NV_point_sprite ()
 
 #ifdef GL_NV_polygon_mode
 
-static GLboolean _glewInit_GL_NV_polygon_mode ()
+static GLboolean _glewInit_GL_NV_polygon_mode (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16271,7 +16667,7 @@ static GLboolean _glewInit_GL_NV_polygon_mode ()
 
 #ifdef GL_NV_present_video
 
-static GLboolean _glewInit_GL_NV_present_video ()
+static GLboolean _glewInit_GL_NV_present_video (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16289,7 +16685,7 @@ static GLboolean _glewInit_GL_NV_present_video ()
 
 #ifdef GL_NV_primitive_restart
 
-static GLboolean _glewInit_GL_NV_primitive_restart ()
+static GLboolean _glewInit_GL_NV_primitive_restart (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16303,7 +16699,7 @@ static GLboolean _glewInit_GL_NV_primitive_restart ()
 
 #ifdef GL_NV_read_buffer
 
-static GLboolean _glewInit_GL_NV_read_buffer ()
+static GLboolean _glewInit_GL_NV_read_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16316,7 +16712,7 @@ static GLboolean _glewInit_GL_NV_read_buffer ()
 
 #ifdef GL_NV_register_combiners
 
-static GLboolean _glewInit_GL_NV_register_combiners ()
+static GLboolean _glewInit_GL_NV_register_combiners (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16341,7 +16737,7 @@ static GLboolean _glewInit_GL_NV_register_combiners ()
 
 #ifdef GL_NV_register_combiners2
 
-static GLboolean _glewInit_GL_NV_register_combiners2 ()
+static GLboolean _glewInit_GL_NV_register_combiners2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16355,7 +16751,7 @@ static GLboolean _glewInit_GL_NV_register_combiners2 ()
 
 #ifdef GL_NV_sample_locations
 
-static GLboolean _glewInit_GL_NV_sample_locations ()
+static GLboolean _glewInit_GL_NV_sample_locations (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16370,7 +16766,7 @@ static GLboolean _glewInit_GL_NV_sample_locations ()
 
 #ifdef GL_NV_scissor_exclusive
 
-static GLboolean _glewInit_GL_NV_scissor_exclusive ()
+static GLboolean _glewInit_GL_NV_scissor_exclusive (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16384,7 +16780,7 @@ static GLboolean _glewInit_GL_NV_scissor_exclusive ()
 
 #ifdef GL_NV_shader_buffer_load
 
-static GLboolean _glewInit_GL_NV_shader_buffer_load ()
+static GLboolean _glewInit_GL_NV_shader_buffer_load (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16409,7 +16805,7 @@ static GLboolean _glewInit_GL_NV_shader_buffer_load ()
 
 #ifdef GL_NV_shading_rate_image
 
-static GLboolean _glewInit_GL_NV_shading_rate_image ()
+static GLboolean _glewInit_GL_NV_shading_rate_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16419,6 +16815,7 @@ static GLboolean _glewInit_GL_NV_shading_rate_image ()
   r = ((glShadingRateImageBarrierNV = (PFNGLSHADINGRATEIMAGEBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateImageBarrierNV")) == NULL) || r;
   r = ((glShadingRateImagePaletteNV = (PFNGLSHADINGRATEIMAGEPALETTENVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateImagePaletteNV")) == NULL) || r;
   r = ((glShadingRateSampleOrderCustomNV = (PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateSampleOrderCustomNV")) == NULL) || r;
+  r = ((glShadingRateSampleOrderNV = (PFNGLSHADINGRATESAMPLEORDERNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateSampleOrderNV")) == NULL) || r;
 
   return r;
 }
@@ -16427,7 +16824,7 @@ static GLboolean _glewInit_GL_NV_shading_rate_image ()
 
 #ifdef GL_NV_texture_array
 
-static GLboolean _glewInit_GL_NV_texture_array ()
+static GLboolean _glewInit_GL_NV_texture_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16445,7 +16842,7 @@ static GLboolean _glewInit_GL_NV_texture_array ()
 
 #ifdef GL_NV_texture_barrier
 
-static GLboolean _glewInit_GL_NV_texture_barrier ()
+static GLboolean _glewInit_GL_NV_texture_barrier (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16458,7 +16855,7 @@ static GLboolean _glewInit_GL_NV_texture_barrier ()
 
 #ifdef GL_NV_texture_multisample
 
-static GLboolean _glewInit_GL_NV_texture_multisample ()
+static GLboolean _glewInit_GL_NV_texture_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16474,9 +16871,24 @@ static GLboolean _glewInit_GL_NV_texture_multisample ()
 
 #endif /* GL_NV_texture_multisample */
 
+#ifdef GL_NV_timeline_semaphore
+
+static GLboolean _glewInit_GL_NV_timeline_semaphore (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glCreateSemaphoresNV = (PFNGLCREATESEMAPHORESNVPROC)glewGetProcAddress((const GLubyte*)"glCreateSemaphoresNV")) == NULL) || r;
+  r = ((glGetSemaphoreParameterivNV = (PFNGLGETSEMAPHOREPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetSemaphoreParameterivNV")) == NULL) || r;
+  r = ((glSemaphoreParameterivNV = (PFNGLSEMAPHOREPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glSemaphoreParameterivNV")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_NV_timeline_semaphore */
+
 #ifdef GL_NV_transform_feedback
 
-static GLboolean _glewInit_GL_NV_transform_feedback ()
+static GLboolean _glewInit_GL_NV_transform_feedback (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16499,7 +16911,7 @@ static GLboolean _glewInit_GL_NV_transform_feedback ()
 
 #ifdef GL_NV_transform_feedback2
 
-static GLboolean _glewInit_GL_NV_transform_feedback2 ()
+static GLboolean _glewInit_GL_NV_transform_feedback2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16518,7 +16930,7 @@ static GLboolean _glewInit_GL_NV_transform_feedback2 ()
 
 #ifdef GL_NV_vdpau_interop
 
-static GLboolean _glewInit_GL_NV_vdpau_interop ()
+static GLboolean _glewInit_GL_NV_vdpau_interop (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16540,7 +16952,7 @@ static GLboolean _glewInit_GL_NV_vdpau_interop ()
 
 #ifdef GL_NV_vdpau_interop2
 
-static GLboolean _glewInit_GL_NV_vdpau_interop2 ()
+static GLboolean _glewInit_GL_NV_vdpau_interop2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16553,7 +16965,7 @@ static GLboolean _glewInit_GL_NV_vdpau_interop2 ()
 
 #ifdef GL_NV_vertex_array_range
 
-static GLboolean _glewInit_GL_NV_vertex_array_range ()
+static GLboolean _glewInit_GL_NV_vertex_array_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16567,7 +16979,7 @@ static GLboolean _glewInit_GL_NV_vertex_array_range ()
 
 #ifdef GL_NV_vertex_attrib_integer_64bit
 
-static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit ()
+static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16598,7 +17010,7 @@ static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit ()
 
 #ifdef GL_NV_vertex_buffer_unified_memory
 
-static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory ()
+static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16622,7 +17034,7 @@ static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory ()
 
 #ifdef GL_NV_vertex_program
 
-static GLboolean _glewInit_GL_NV_vertex_program ()
+static GLboolean _glewInit_GL_NV_vertex_program (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16698,7 +17110,7 @@ static GLboolean _glewInit_GL_NV_vertex_program ()
 
 #ifdef GL_NV_video_capture
 
-static GLboolean _glewInit_GL_NV_video_capture ()
+static GLboolean _glewInit_GL_NV_video_capture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16722,7 +17134,7 @@ static GLboolean _glewInit_GL_NV_video_capture ()
 
 #ifdef GL_NV_viewport_array
 
-static GLboolean _glewInit_GL_NV_viewport_array ()
+static GLboolean _glewInit_GL_NV_viewport_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16746,7 +17158,7 @@ static GLboolean _glewInit_GL_NV_viewport_array ()
 
 #ifdef GL_NV_viewport_swizzle
 
-static GLboolean _glewInit_GL_NV_viewport_swizzle ()
+static GLboolean _glewInit_GL_NV_viewport_swizzle (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16759,7 +17171,7 @@ static GLboolean _glewInit_GL_NV_viewport_swizzle ()
 
 #ifdef GL_OES_EGL_image
 
-static GLboolean _glewInit_GL_OES_EGL_image ()
+static GLboolean _glewInit_GL_OES_EGL_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16773,7 +17185,7 @@ static GLboolean _glewInit_GL_OES_EGL_image ()
 
 #ifdef GL_OES_blend_equation_separate
 
-static GLboolean _glewInit_GL_OES_blend_equation_separate ()
+static GLboolean _glewInit_GL_OES_blend_equation_separate (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16786,7 +17198,7 @@ static GLboolean _glewInit_GL_OES_blend_equation_separate ()
 
 #ifdef GL_OES_blend_func_separate
 
-static GLboolean _glewInit_GL_OES_blend_func_separate ()
+static GLboolean _glewInit_GL_OES_blend_func_separate (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16799,7 +17211,7 @@ static GLboolean _glewInit_GL_OES_blend_func_separate ()
 
 #ifdef GL_OES_blend_subtract
 
-static GLboolean _glewInit_GL_OES_blend_subtract ()
+static GLboolean _glewInit_GL_OES_blend_subtract (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16812,7 +17224,7 @@ static GLboolean _glewInit_GL_OES_blend_subtract ()
 
 #ifdef GL_OES_copy_image
 
-static GLboolean _glewInit_GL_OES_copy_image ()
+static GLboolean _glewInit_GL_OES_copy_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16825,7 +17237,7 @@ static GLboolean _glewInit_GL_OES_copy_image ()
 
 #ifdef GL_OES_draw_buffers_indexed
 
-static GLboolean _glewInit_GL_OES_draw_buffers_indexed ()
+static GLboolean _glewInit_GL_OES_draw_buffers_indexed (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16845,7 +17257,7 @@ static GLboolean _glewInit_GL_OES_draw_buffers_indexed ()
 
 #ifdef GL_OES_framebuffer_object
 
-static GLboolean _glewInit_GL_OES_framebuffer_object ()
+static GLboolean _glewInit_GL_OES_framebuffer_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16872,7 +17284,7 @@ static GLboolean _glewInit_GL_OES_framebuffer_object ()
 
 #ifdef GL_OES_get_program_binary
 
-static GLboolean _glewInit_GL_OES_get_program_binary ()
+static GLboolean _glewInit_GL_OES_get_program_binary (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16886,7 +17298,7 @@ static GLboolean _glewInit_GL_OES_get_program_binary ()
 
 #ifdef GL_OES_mapbuffer
 
-static GLboolean _glewInit_GL_OES_mapbuffer ()
+static GLboolean _glewInit_GL_OES_mapbuffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16901,11 +17313,12 @@ static GLboolean _glewInit_GL_OES_mapbuffer ()
 
 #ifdef GL_OES_matrix_palette
 
-static GLboolean _glewInit_GL_OES_matrix_palette ()
+static GLboolean _glewInit_GL_OES_matrix_palette (void)
 {
   GLboolean r = GL_FALSE;
 
   r = ((glCurrentPaletteMatrixOES = (PFNGLCURRENTPALETTEMATRIXOESPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixOES")) == NULL) || r;
+  r = ((glLoadPaletteFromModelViewMatrixOES = (PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC)glewGetProcAddress((const GLubyte*)"glLoadPaletteFromModelViewMatrixOES")) == NULL) || r;
   r = ((glMatrixIndexPointerOES = (PFNGLMATRIXINDEXPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerOES")) == NULL) || r;
   r = ((glWeightPointerOES = (PFNGLWEIGHTPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerOES")) == NULL) || r;
 
@@ -16916,7 +17329,7 @@ static GLboolean _glewInit_GL_OES_matrix_palette ()
 
 #ifdef GL_OES_sample_shading
 
-static GLboolean _glewInit_GL_OES_sample_shading ()
+static GLboolean _glewInit_GL_OES_sample_shading (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16929,7 +17342,7 @@ static GLboolean _glewInit_GL_OES_sample_shading ()
 
 #ifdef GL_OES_single_precision
 
-static GLboolean _glewInit_GL_OES_single_precision ()
+static GLboolean _glewInit_GL_OES_single_precision (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16947,7 +17360,7 @@ static GLboolean _glewInit_GL_OES_single_precision ()
 
 #ifdef GL_OES_texture_3D
 
-static GLboolean _glewInit_GL_OES_texture_3D ()
+static GLboolean _glewInit_GL_OES_texture_3D (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16965,7 +17378,7 @@ static GLboolean _glewInit_GL_OES_texture_3D ()
 
 #ifdef GL_OES_texture_border_clamp
 
-static GLboolean _glewInit_GL_OES_texture_border_clamp ()
+static GLboolean _glewInit_GL_OES_texture_border_clamp (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16985,7 +17398,7 @@ static GLboolean _glewInit_GL_OES_texture_border_clamp ()
 
 #ifdef GL_OES_texture_buffer
 
-static GLboolean _glewInit_GL_OES_texture_buffer ()
+static GLboolean _glewInit_GL_OES_texture_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -16999,7 +17412,7 @@ static GLboolean _glewInit_GL_OES_texture_buffer ()
 
 #ifdef GL_OES_texture_cube_map
 
-static GLboolean _glewInit_GL_OES_texture_cube_map ()
+static GLboolean _glewInit_GL_OES_texture_cube_map (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17020,7 +17433,7 @@ static GLboolean _glewInit_GL_OES_texture_cube_map ()
 
 #ifdef GL_OES_texture_storage_multisample_2d_array
 
-static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array ()
+static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17033,7 +17446,7 @@ static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array ()
 
 #ifdef GL_OES_texture_view
 
-static GLboolean _glewInit_GL_OES_texture_view ()
+static GLboolean _glewInit_GL_OES_texture_view (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17046,7 +17459,7 @@ static GLboolean _glewInit_GL_OES_texture_view ()
 
 #ifdef GL_OES_vertex_array_object
 
-static GLboolean _glewInit_GL_OES_vertex_array_object ()
+static GLboolean _glewInit_GL_OES_vertex_array_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17062,7 +17475,7 @@ static GLboolean _glewInit_GL_OES_vertex_array_object ()
 
 #ifdef GL_OVR_multiview
 
-static GLboolean _glewInit_GL_OVR_multiview ()
+static GLboolean _glewInit_GL_OVR_multiview (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17076,7 +17489,7 @@ static GLboolean _glewInit_GL_OVR_multiview ()
 
 #ifdef GL_OVR_multiview_multisampled_render_to_texture
 
-static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture ()
+static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17089,7 +17502,7 @@ static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture ()
 
 #ifdef GL_QCOM_alpha_test
 
-static GLboolean _glewInit_GL_QCOM_alpha_test ()
+static GLboolean _glewInit_GL_QCOM_alpha_test (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17102,7 +17515,7 @@ static GLboolean _glewInit_GL_QCOM_alpha_test ()
 
 #ifdef GL_QCOM_driver_control
 
-static GLboolean _glewInit_GL_QCOM_driver_control ()
+static GLboolean _glewInit_GL_QCOM_driver_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17118,7 +17531,7 @@ static GLboolean _glewInit_GL_QCOM_driver_control ()
 
 #ifdef GL_QCOM_extended_get
 
-static GLboolean _glewInit_GL_QCOM_extended_get ()
+static GLboolean _glewInit_GL_QCOM_extended_get (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17138,7 +17551,7 @@ static GLboolean _glewInit_GL_QCOM_extended_get ()
 
 #ifdef GL_QCOM_extended_get2
 
-static GLboolean _glewInit_GL_QCOM_extended_get2 ()
+static GLboolean _glewInit_GL_QCOM_extended_get2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17152,9 +17565,22 @@ static GLboolean _glewInit_GL_QCOM_extended_get2 ()
 
 #endif /* GL_QCOM_extended_get2 */
 
+#ifdef GL_QCOM_frame_extrapolation
+
+static GLboolean _glewInit_GL_QCOM_frame_extrapolation (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glExtrapolateTex2DQCOM = (PFNGLEXTRAPOLATETEX2DQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtrapolateTex2DQCOM")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_QCOM_frame_extrapolation */
+
 #ifdef GL_QCOM_framebuffer_foveated
 
-static GLboolean _glewInit_GL_QCOM_framebuffer_foveated ()
+static GLboolean _glewInit_GL_QCOM_framebuffer_foveated (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17166,9 +17592,23 @@ static GLboolean _glewInit_GL_QCOM_framebuffer_foveated ()
 
 #endif /* GL_QCOM_framebuffer_foveated */
 
+#ifdef GL_QCOM_motion_estimation
+
+static GLboolean _glewInit_GL_QCOM_motion_estimation (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glTexEstimateMotionQCOM = (PFNGLTEXESTIMATEMOTIONQCOMPROC)glewGetProcAddress((const GLubyte*)"glTexEstimateMotionQCOM")) == NULL) || r;
+  r = ((glTexEstimateMotionRegionsQCOM = (PFNGLTEXESTIMATEMOTIONREGIONSQCOMPROC)glewGetProcAddress((const GLubyte*)"glTexEstimateMotionRegionsQCOM")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_QCOM_motion_estimation */
+
 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent
 
-static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent ()
+static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17179,9 +17619,22 @@ static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent ()
 
 #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */
 
+#ifdef GL_QCOM_shading_rate
+
+static GLboolean _glewInit_GL_QCOM_shading_rate (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((glShadingRateQCOM = (PFNGLSHADINGRATEQCOMPROC)glewGetProcAddress((const GLubyte*)"glShadingRateQCOM")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* GL_QCOM_shading_rate */
+
 #ifdef GL_QCOM_texture_foveated
 
-static GLboolean _glewInit_GL_QCOM_texture_foveated ()
+static GLboolean _glewInit_GL_QCOM_texture_foveated (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17194,7 +17647,7 @@ static GLboolean _glewInit_GL_QCOM_texture_foveated ()
 
 #ifdef GL_QCOM_tiled_rendering
 
-static GLboolean _glewInit_GL_QCOM_tiled_rendering ()
+static GLboolean _glewInit_GL_QCOM_tiled_rendering (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17208,7 +17661,7 @@ static GLboolean _glewInit_GL_QCOM_tiled_rendering ()
 
 #ifdef GL_REGAL_ES1_0_compatibility
 
-static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility ()
+static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17251,7 +17704,7 @@ static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility ()
 
 #ifdef GL_REGAL_ES1_1_compatibility
 
-static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility ()
+static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17276,7 +17729,7 @@ static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility ()
 
 #ifdef GL_REGAL_error_string
 
-static GLboolean _glewInit_GL_REGAL_error_string ()
+static GLboolean _glewInit_GL_REGAL_error_string (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17289,7 +17742,7 @@ static GLboolean _glewInit_GL_REGAL_error_string ()
 
 #ifdef GL_REGAL_extension_query
 
-static GLboolean _glewInit_GL_REGAL_extension_query ()
+static GLboolean _glewInit_GL_REGAL_extension_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17303,7 +17756,7 @@ static GLboolean _glewInit_GL_REGAL_extension_query ()
 
 #ifdef GL_REGAL_log
 
-static GLboolean _glewInit_GL_REGAL_log ()
+static GLboolean _glewInit_GL_REGAL_log (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17316,7 +17769,7 @@ static GLboolean _glewInit_GL_REGAL_log ()
 
 #ifdef GL_REGAL_proc_address
 
-static GLboolean _glewInit_GL_REGAL_proc_address ()
+static GLboolean _glewInit_GL_REGAL_proc_address (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17329,7 +17782,7 @@ static GLboolean _glewInit_GL_REGAL_proc_address ()
 
 #ifdef GL_SGIS_detail_texture
 
-static GLboolean _glewInit_GL_SGIS_detail_texture ()
+static GLboolean _glewInit_GL_SGIS_detail_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17343,7 +17796,7 @@ static GLboolean _glewInit_GL_SGIS_detail_texture ()
 
 #ifdef GL_SGIS_fog_function
 
-static GLboolean _glewInit_GL_SGIS_fog_function ()
+static GLboolean _glewInit_GL_SGIS_fog_function (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17357,7 +17810,7 @@ static GLboolean _glewInit_GL_SGIS_fog_function ()
 
 #ifdef GL_SGIS_multisample
 
-static GLboolean _glewInit_GL_SGIS_multisample ()
+static GLboolean _glewInit_GL_SGIS_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17371,7 +17824,7 @@ static GLboolean _glewInit_GL_SGIS_multisample ()
 
 #ifdef GL_SGIS_multitexture
 
-static GLboolean _glewInit_GL_SGIS_multitexture ()
+static GLboolean _glewInit_GL_SGIS_multitexture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17387,7 +17840,7 @@ static GLboolean _glewInit_GL_SGIS_multitexture ()
 
 #ifdef GL_SGIS_shared_multisample
 
-static GLboolean _glewInit_GL_SGIS_shared_multisample ()
+static GLboolean _glewInit_GL_SGIS_shared_multisample (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17400,7 +17853,7 @@ static GLboolean _glewInit_GL_SGIS_shared_multisample ()
 
 #ifdef GL_SGIS_sharpen_texture
 
-static GLboolean _glewInit_GL_SGIS_sharpen_texture ()
+static GLboolean _glewInit_GL_SGIS_sharpen_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17414,7 +17867,7 @@ static GLboolean _glewInit_GL_SGIS_sharpen_texture ()
 
 #ifdef GL_SGIS_texture4D
 
-static GLboolean _glewInit_GL_SGIS_texture4D ()
+static GLboolean _glewInit_GL_SGIS_texture4D (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17428,7 +17881,7 @@ static GLboolean _glewInit_GL_SGIS_texture4D ()
 
 #ifdef GL_SGIS_texture_filter4
 
-static GLboolean _glewInit_GL_SGIS_texture_filter4 ()
+static GLboolean _glewInit_GL_SGIS_texture_filter4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17442,7 +17895,7 @@ static GLboolean _glewInit_GL_SGIS_texture_filter4 ()
 
 #ifdef GL_SGIX_async
 
-static GLboolean _glewInit_GL_SGIX_async ()
+static GLboolean _glewInit_GL_SGIX_async (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17460,7 +17913,7 @@ static GLboolean _glewInit_GL_SGIX_async ()
 
 #ifdef GL_SGIX_datapipe
 
-static GLboolean _glewInit_GL_SGIX_datapipe ()
+static GLboolean _glewInit_GL_SGIX_datapipe (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17474,7 +17927,7 @@ static GLboolean _glewInit_GL_SGIX_datapipe ()
 
 #ifdef GL_SGIX_flush_raster
 
-static GLboolean _glewInit_GL_SGIX_flush_raster ()
+static GLboolean _glewInit_GL_SGIX_flush_raster (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17487,7 +17940,7 @@ static GLboolean _glewInit_GL_SGIX_flush_raster ()
 
 #ifdef GL_SGIX_fog_layers
 
-static GLboolean _glewInit_GL_SGIX_fog_layers ()
+static GLboolean _glewInit_GL_SGIX_fog_layers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17501,7 +17954,7 @@ static GLboolean _glewInit_GL_SGIX_fog_layers ()
 
 #ifdef GL_SGIX_fog_texture
 
-static GLboolean _glewInit_GL_SGIX_fog_texture ()
+static GLboolean _glewInit_GL_SGIX_fog_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17514,7 +17967,7 @@ static GLboolean _glewInit_GL_SGIX_fog_texture ()
 
 #ifdef GL_SGIX_fragment_specular_lighting
 
-static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting ()
+static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17543,7 +17996,7 @@ static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting ()
 
 #ifdef GL_SGIX_framezoom
 
-static GLboolean _glewInit_GL_SGIX_framezoom ()
+static GLboolean _glewInit_GL_SGIX_framezoom (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17556,7 +18009,7 @@ static GLboolean _glewInit_GL_SGIX_framezoom ()
 
 #ifdef GL_SGIX_igloo_interface
 
-static GLboolean _glewInit_GL_SGIX_igloo_interface ()
+static GLboolean _glewInit_GL_SGIX_igloo_interface (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17569,7 +18022,7 @@ static GLboolean _glewInit_GL_SGIX_igloo_interface ()
 
 #ifdef GL_SGIX_mpeg1
 
-static GLboolean _glewInit_GL_SGIX_mpeg1 ()
+static GLboolean _glewInit_GL_SGIX_mpeg1 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17592,7 +18045,7 @@ static GLboolean _glewInit_GL_SGIX_mpeg1 ()
 
 #ifdef GL_SGIX_nonlinear_lighting_pervertex
 
-static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex ()
+static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17608,7 +18061,7 @@ static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex ()
 
 #ifdef GL_SGIX_pixel_texture
 
-static GLboolean _glewInit_GL_SGIX_pixel_texture ()
+static GLboolean _glewInit_GL_SGIX_pixel_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17621,7 +18074,7 @@ static GLboolean _glewInit_GL_SGIX_pixel_texture ()
 
 #ifdef GL_SGIX_polynomial_ffd
 
-static GLboolean _glewInit_GL_SGIX_polynomial_ffd ()
+static GLboolean _glewInit_GL_SGIX_polynomial_ffd (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17635,7 +18088,7 @@ static GLboolean _glewInit_GL_SGIX_polynomial_ffd ()
 
 #ifdef GL_SGIX_quad_mesh
 
-static GLboolean _glewInit_GL_SGIX_quad_mesh ()
+static GLboolean _glewInit_GL_SGIX_quad_mesh (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17649,7 +18102,7 @@ static GLboolean _glewInit_GL_SGIX_quad_mesh ()
 
 #ifdef GL_SGIX_reference_plane
 
-static GLboolean _glewInit_GL_SGIX_reference_plane ()
+static GLboolean _glewInit_GL_SGIX_reference_plane (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17662,7 +18115,7 @@ static GLboolean _glewInit_GL_SGIX_reference_plane ()
 
 #ifdef GL_SGIX_sprite
 
-static GLboolean _glewInit_GL_SGIX_sprite ()
+static GLboolean _glewInit_GL_SGIX_sprite (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17678,7 +18131,7 @@ static GLboolean _glewInit_GL_SGIX_sprite ()
 
 #ifdef GL_SGIX_tag_sample_buffer
 
-static GLboolean _glewInit_GL_SGIX_tag_sample_buffer ()
+static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17691,7 +18144,7 @@ static GLboolean _glewInit_GL_SGIX_tag_sample_buffer ()
 
 #ifdef GL_SGIX_vector_ops
 
-static GLboolean _glewInit_GL_SGIX_vector_ops ()
+static GLboolean _glewInit_GL_SGIX_vector_ops (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17705,7 +18158,7 @@ static GLboolean _glewInit_GL_SGIX_vector_ops ()
 
 #ifdef GL_SGIX_vertex_array_object
 
-static GLboolean _glewInit_GL_SGIX_vertex_array_object ()
+static GLboolean _glewInit_GL_SGIX_vertex_array_object (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17723,7 +18176,7 @@ static GLboolean _glewInit_GL_SGIX_vertex_array_object ()
 
 #ifdef GL_SGI_color_table
 
-static GLboolean _glewInit_GL_SGI_color_table ()
+static GLboolean _glewInit_GL_SGI_color_table (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17742,7 +18195,7 @@ static GLboolean _glewInit_GL_SGI_color_table ()
 
 #ifdef GL_SGI_fft
 
-static GLboolean _glewInit_GL_SGI_fft ()
+static GLboolean _glewInit_GL_SGI_fft (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17761,7 +18214,7 @@ static GLboolean _glewInit_GL_SGI_fft ()
 
 #ifdef GL_SUNX_constant_data
 
-static GLboolean _glewInit_GL_SUNX_constant_data ()
+static GLboolean _glewInit_GL_SUNX_constant_data (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17774,7 +18227,7 @@ static GLboolean _glewInit_GL_SUNX_constant_data ()
 
 #ifdef GL_SUN_global_alpha
 
-static GLboolean _glewInit_GL_SUN_global_alpha ()
+static GLboolean _glewInit_GL_SUN_global_alpha (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17794,7 +18247,7 @@ static GLboolean _glewInit_GL_SUN_global_alpha ()
 
 #ifdef GL_SUN_read_video_pixels
 
-static GLboolean _glewInit_GL_SUN_read_video_pixels ()
+static GLboolean _glewInit_GL_SUN_read_video_pixels (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17807,7 +18260,7 @@ static GLboolean _glewInit_GL_SUN_read_video_pixels ()
 
 #ifdef GL_SUN_triangle_list
 
-static GLboolean _glewInit_GL_SUN_triangle_list ()
+static GLboolean _glewInit_GL_SUN_triangle_list (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17826,7 +18279,7 @@ static GLboolean _glewInit_GL_SUN_triangle_list ()
 
 #ifdef GL_SUN_vertex
 
-static GLboolean _glewInit_GL_SUN_vertex ()
+static GLboolean _glewInit_GL_SUN_vertex (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17878,7 +18331,7 @@ static GLboolean _glewInit_GL_SUN_vertex ()
 
 #ifdef GL_WIN_swap_hint
 
-static GLboolean _glewInit_GL_WIN_swap_hint ()
+static GLboolean _glewInit_GL_WIN_swap_hint (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -17964,7 +18417,7 @@ GLboolean GLEWAPIENTRY glewGetExtension (const char* name)
 typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGPROC) (GLenum name);
 typedef void (GLAPIENTRY * PFNGLGETINTEGERVPROC) (GLenum pname, GLint *params);
 
-static GLenum GLEWAPIENTRY glewContextInit ()
+GLenum GLEWAPIENTRY glewContextInit (void)
 {
   PFNGLGETSTRINGPROC getString;
   const GLubyte* s;
@@ -18488,6 +18941,9 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_ARB_window_pos
   if (glewExperimental || GLEW_ARB_window_pos) GLEW_ARB_window_pos = !_glewInit_GL_ARB_window_pos();
 #endif /* GL_ARB_window_pos */
+#ifdef GL_ARM_shader_core_properties
+  if (glewExperimental || GLEW_ARM_shader_core_properties) GLEW_ARM_shader_core_properties = !_glewInit_GL_ARM_shader_core_properties();
+#endif /* GL_ARM_shader_core_properties */
 #ifdef GL_ATI_draw_buffers
   if (glewExperimental || GLEW_ATI_draw_buffers) GLEW_ATI_draw_buffers = !_glewInit_GL_ATI_draw_buffers();
 #endif /* GL_ATI_draw_buffers */
@@ -18620,9 +19076,15 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_EXT_fragment_lighting
   if (glewExperimental || GLEW_EXT_fragment_lighting) GLEW_EXT_fragment_lighting = !_glewInit_GL_EXT_fragment_lighting();
 #endif /* GL_EXT_fragment_lighting */
+#ifdef GL_EXT_fragment_shading_rate
+  if (glewExperimental || GLEW_EXT_fragment_shading_rate) GLEW_EXT_fragment_shading_rate = !_glewInit_GL_EXT_fragment_shading_rate();
+#endif /* GL_EXT_fragment_shading_rate */
 #ifdef GL_EXT_framebuffer_blit
   if (glewExperimental || GLEW_EXT_framebuffer_blit) GLEW_EXT_framebuffer_blit = !_glewInit_GL_EXT_framebuffer_blit();
 #endif /* GL_EXT_framebuffer_blit */
+#ifdef GL_EXT_framebuffer_blit_layers
+  if (glewExperimental || GLEW_EXT_framebuffer_blit_layers) GLEW_EXT_framebuffer_blit_layers = !_glewInit_GL_EXT_framebuffer_blit_layers();
+#endif /* GL_EXT_framebuffer_blit_layers */
 #ifdef GL_EXT_framebuffer_multisample
   if (glewExperimental || GLEW_EXT_framebuffer_multisample) GLEW_EXT_framebuffer_multisample = !_glewInit_GL_EXT_framebuffer_multisample();
 #endif /* GL_EXT_framebuffer_multisample */
@@ -18665,6 +19127,9 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_EXT_memory_object_win32
   if (glewExperimental || GLEW_EXT_memory_object_win32) GLEW_EXT_memory_object_win32 = !_glewInit_GL_EXT_memory_object_win32();
 #endif /* GL_EXT_memory_object_win32 */
+#ifdef GL_EXT_mesh_shader
+  if (glewExperimental || GLEW_EXT_mesh_shader) GLEW_EXT_mesh_shader = !_glewInit_GL_EXT_mesh_shader();
+#endif /* GL_EXT_mesh_shader */
 #ifdef GL_EXT_multi_draw_arrays
   if (glewExperimental || GLEW_EXT_multi_draw_arrays) GLEW_EXT_multi_draw_arrays = !_glewInit_GL_EXT_multi_draw_arrays();
 #endif /* GL_EXT_multi_draw_arrays */
@@ -18770,6 +19235,9 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_EXT_texture_storage
   if (glewExperimental || GLEW_EXT_texture_storage) GLEW_EXT_texture_storage = !_glewInit_GL_EXT_texture_storage();
 #endif /* GL_EXT_texture_storage */
+#ifdef GL_EXT_texture_storage_compression
+  if (glewExperimental || GLEW_EXT_texture_storage_compression) GLEW_EXT_texture_storage_compression = !_glewInit_GL_EXT_texture_storage_compression();
+#endif /* GL_EXT_texture_storage_compression */
 #ifdef GL_EXT_texture_view
   if (glewExperimental || GLEW_EXT_texture_view) GLEW_EXT_texture_view = !_glewInit_GL_EXT_texture_view();
 #endif /* GL_EXT_texture_view */
@@ -18827,6 +19295,9 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_IMG_multisampled_render_to_texture
   if (glewExperimental || GLEW_IMG_multisampled_render_to_texture) GLEW_IMG_multisampled_render_to_texture = !_glewInit_GL_IMG_multisampled_render_to_texture();
 #endif /* GL_IMG_multisampled_render_to_texture */
+#ifdef GL_INTEL_framebuffer_CMAA
+  if (glewExperimental || GLEW_INTEL_framebuffer_CMAA) GLEW_INTEL_framebuffer_CMAA = !_glewInit_GL_INTEL_framebuffer_CMAA();
+#endif /* GL_INTEL_framebuffer_CMAA */
 #ifdef GL_INTEL_map_texture
   if (glewExperimental || GLEW_INTEL_map_texture) GLEW_INTEL_map_texture = !_glewInit_GL_INTEL_map_texture();
 #endif /* GL_INTEL_map_texture */
@@ -18980,6 +19451,9 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_NV_memory_attachment
   if (glewExperimental || GLEW_NV_memory_attachment) GLEW_NV_memory_attachment = !_glewInit_GL_NV_memory_attachment();
 #endif /* GL_NV_memory_attachment */
+#ifdef GL_NV_memory_object_sparse
+  if (glewExperimental || GLEW_NV_memory_object_sparse) GLEW_NV_memory_object_sparse = !_glewInit_GL_NV_memory_object_sparse();
+#endif /* GL_NV_memory_object_sparse */
 #ifdef GL_NV_mesh_shader
   if (glewExperimental || GLEW_NV_mesh_shader) GLEW_NV_mesh_shader = !_glewInit_GL_NV_mesh_shader();
 #endif /* GL_NV_mesh_shader */
@@ -19040,6 +19514,9 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_NV_texture_multisample
   if (glewExperimental || GLEW_NV_texture_multisample) GLEW_NV_texture_multisample = !_glewInit_GL_NV_texture_multisample();
 #endif /* GL_NV_texture_multisample */
+#ifdef GL_NV_timeline_semaphore
+  if (glewExperimental || GLEW_NV_timeline_semaphore) GLEW_NV_timeline_semaphore = !_glewInit_GL_NV_timeline_semaphore();
+#endif /* GL_NV_timeline_semaphore */
 #ifdef GL_NV_transform_feedback
   if (glewExperimental || GLEW_NV_transform_feedback) GLEW_NV_transform_feedback = !_glewInit_GL_NV_transform_feedback();
 #endif /* GL_NV_transform_feedback */
@@ -19148,12 +19625,21 @@ static GLenum GLEWAPIENTRY glewContextInit ()
 #ifdef GL_QCOM_extended_get2
   if (glewExperimental || GLEW_QCOM_extended_get2) GLEW_QCOM_extended_get2 = !_glewInit_GL_QCOM_extended_get2();
 #endif /* GL_QCOM_extended_get2 */
+#ifdef GL_QCOM_frame_extrapolation
+  if (glewExperimental || GLEW_QCOM_frame_extrapolation) GLEW_QCOM_frame_extrapolation = !_glewInit_GL_QCOM_frame_extrapolation();
+#endif /* GL_QCOM_frame_extrapolation */
 #ifdef GL_QCOM_framebuffer_foveated
   if (glewExperimental || GLEW_QCOM_framebuffer_foveated) GLEW_QCOM_framebuffer_foveated = !_glewInit_GL_QCOM_framebuffer_foveated();
 #endif /* GL_QCOM_framebuffer_foveated */
+#ifdef GL_QCOM_motion_estimation
+  if (glewExperimental || GLEW_QCOM_motion_estimation) GLEW_QCOM_motion_estimation = !_glewInit_GL_QCOM_motion_estimation();
+#endif /* GL_QCOM_motion_estimation */
 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent
   if (glewExperimental || GLEW_QCOM_shader_framebuffer_fetch_noncoherent) GLEW_QCOM_shader_framebuffer_fetch_noncoherent = !_glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent();
 #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */
+#ifdef GL_QCOM_shading_rate
+  if (glewExperimental || GLEW_QCOM_shading_rate) GLEW_QCOM_shading_rate = !_glewInit_GL_QCOM_shading_rate();
+#endif /* GL_QCOM_shading_rate */
 #ifdef GL_QCOM_texture_foveated
   if (glewExperimental || GLEW_QCOM_texture_foveated) GLEW_QCOM_texture_foveated = !_glewInit_GL_QCOM_texture_foveated();
 #endif /* GL_QCOM_texture_foveated */
@@ -19367,6 +19853,8 @@ PFNEGLPRESENTATIONTIMEANDROIDPROC __eglewPresentationTimeANDROID = NULL;
 
 PFNEGLQUERYSURFACEPOINTERANGLEPROC __eglewQuerySurfacePointerANGLE = NULL;
 
+PFNEGLGETMSCRATEANGLEPROC __eglewGetMscRateANGLE = NULL;
+
 PFNEGLCLIENTSIGNALSYNCEXTPROC __eglewClientSignalSyncEXT = NULL;
 
 PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC __eglewCompositorBindTexWindowEXT = NULL;
@@ -19379,10 +19867,14 @@ PFNEGLCOMPOSITORSWAPPOLICYEXTPROC __eglewCompositorSwapPolicyEXT = NULL;
 
 PFNEGLQUERYDEVICESEXTPROC __eglewQueryDevicesEXT = NULL;
 
+PFNEGLQUERYDEVICEBINARYEXTPROC __eglewQueryDeviceBinaryEXT = NULL;
+
 PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT = NULL;
 PFNEGLQUERYDEVICESTRINGEXTPROC __eglewQueryDeviceStringEXT = NULL;
 PFNEGLQUERYDISPLAYATTRIBEXTPROC __eglewQueryDisplayAttribEXT = NULL;
 
+PFNEGLDESTROYDISPLAYEXTPROC __eglewDestroyDisplayEXT = NULL;
+
 PFNEGLQUERYDMABUFFORMATSEXTPROC __eglewQueryDmaBufFormatsEXT = NULL;
 PFNEGLQUERYDMABUFMODIFIERSEXTPROC __eglewQueryDmaBufModifiersEXT = NULL;
 
@@ -19401,6 +19893,8 @@ PFNEGLGETPLATFORMDISPLAYEXTPROC __eglewGetPlatformDisplayEXT = NULL;
 
 PFNEGLSTREAMCONSUMEROUTPUTEXTPROC __eglewStreamConsumerOutputEXT = NULL;
 
+PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC __eglewQuerySupportedCompressionRatesEXT = NULL;
+
 PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC __eglewSwapBuffersWithDamageEXT = NULL;
 
 PFNEGLUNSIGNALSYNCEXTPROC __eglewUnsignalSyncEXT = NULL;
@@ -19477,6 +19971,11 @@ PFNEGLQUERYNATIVEWINDOWNVPROC __eglewQueryNativeWindowNV = NULL;
 
 PFNEGLPOSTSUBBUFFERNVPROC __eglewPostSubBufferNV = NULL;
 
+PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC __eglewQueryStreamConsumerEventNV = NULL;
+PFNEGLSTREAMACQUIREIMAGENVPROC __eglewStreamAcquireImageNV = NULL;
+PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC __eglewStreamImageConsumerConnectNV = NULL;
+PFNEGLSTREAMRELEASEIMAGENVPROC __eglewStreamReleaseImageNV = NULL;
+
 PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC __eglewStreamConsumerGLTextureExternalAttribsNV = NULL;
 
 PFNEGLSTREAMFLUSHNVPROC __eglewStreamFlushNV = NULL;
@@ -19521,10 +20020,12 @@ GLboolean __EGLEW_ANDROID_image_native_buffer = GL_FALSE;
 GLboolean __EGLEW_ANDROID_native_fence_sync = GL_FALSE;
 GLboolean __EGLEW_ANDROID_presentation_time = GL_FALSE;
 GLboolean __EGLEW_ANDROID_recordable = GL_FALSE;
+GLboolean __EGLEW_ANDROID_telemetry_hint = GL_FALSE;
 GLboolean __EGLEW_ANGLE_d3d_share_handle_client_buffer = GL_FALSE;
 GLboolean __EGLEW_ANGLE_device_d3d = GL_FALSE;
 GLboolean __EGLEW_ANGLE_query_surface_pointer = GL_FALSE;
 GLboolean __EGLEW_ANGLE_surface_d3d_texture_2d_share_handle = GL_FALSE;
+GLboolean __EGLEW_ANGLE_sync_control_rate = GL_FALSE;
 GLboolean __EGLEW_ANGLE_window_fixed_size = GL_FALSE;
 GLboolean __EGLEW_ARM_image_format = GL_FALSE;
 GLboolean __EGLEW_ARM_implicit_external_sync = GL_FALSE;
@@ -19534,12 +20035,19 @@ GLboolean __EGLEW_EXT_buffer_age = GL_FALSE;
 GLboolean __EGLEW_EXT_client_extensions = GL_FALSE;
 GLboolean __EGLEW_EXT_client_sync = GL_FALSE;
 GLboolean __EGLEW_EXT_compositor = GL_FALSE;
+GLboolean __EGLEW_EXT_config_select_group = GL_FALSE;
 GLboolean __EGLEW_EXT_create_context_robustness = GL_FALSE;
 GLboolean __EGLEW_EXT_device_base = GL_FALSE;
 GLboolean __EGLEW_EXT_device_drm = GL_FALSE;
+GLboolean __EGLEW_EXT_device_drm_render_node = GL_FALSE;
 GLboolean __EGLEW_EXT_device_enumeration = GL_FALSE;
 GLboolean __EGLEW_EXT_device_openwf = GL_FALSE;
+GLboolean __EGLEW_EXT_device_persistent_id = GL_FALSE;
 GLboolean __EGLEW_EXT_device_query = GL_FALSE;
+GLboolean __EGLEW_EXT_device_query_name = GL_FALSE;
+GLboolean __EGLEW_EXT_display_alloc = GL_FALSE;
+GLboolean __EGLEW_EXT_explicit_device = GL_FALSE;
+GLboolean __EGLEW_EXT_gl_colorspace_bt2020_hlg = GL_FALSE;
 GLboolean __EGLEW_EXT_gl_colorspace_bt2020_linear = GL_FALSE;
 GLboolean __EGLEW_EXT_gl_colorspace_bt2020_pq = GL_FALSE;
 GLboolean __EGLEW_EXT_gl_colorspace_display_p3 = GL_FALSE;
@@ -19560,11 +20068,15 @@ GLboolean __EGLEW_EXT_platform_base = GL_FALSE;
 GLboolean __EGLEW_EXT_platform_device = GL_FALSE;
 GLboolean __EGLEW_EXT_platform_wayland = GL_FALSE;
 GLboolean __EGLEW_EXT_platform_x11 = GL_FALSE;
+GLboolean __EGLEW_EXT_platform_xcb = GL_FALSE;
+GLboolean __EGLEW_EXT_present_opaque = GL_FALSE;
 GLboolean __EGLEW_EXT_protected_content = GL_FALSE;
 GLboolean __EGLEW_EXT_protected_surface = GL_FALSE;
+GLboolean __EGLEW_EXT_query_reset_notification_strategy = GL_FALSE;
 GLboolean __EGLEW_EXT_stream_consumer_egloutput = GL_FALSE;
 GLboolean __EGLEW_EXT_surface_CTA861_3_metadata = GL_FALSE;
 GLboolean __EGLEW_EXT_surface_SMPTE2086_metadata = GL_FALSE;
+GLboolean __EGLEW_EXT_surface_compression = GL_FALSE;
 GLboolean __EGLEW_EXT_swap_buffers_with_damage = GL_FALSE;
 GLboolean __EGLEW_EXT_sync_reuse = GL_FALSE;
 GLboolean __EGLEW_EXT_yuv_surface = GL_FALSE;
@@ -19633,6 +20145,8 @@ GLboolean __EGLEW_NV_post_convert_rounding = GL_FALSE;
 GLboolean __EGLEW_NV_post_sub_buffer = GL_FALSE;
 GLboolean __EGLEW_NV_quadruple_buffer = GL_FALSE;
 GLboolean __EGLEW_NV_robustness_video_memory_purge = GL_FALSE;
+GLboolean __EGLEW_NV_stream_consumer_eglimage = GL_FALSE;
+GLboolean __EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib = GL_FALSE;
 GLboolean __EGLEW_NV_stream_consumer_gltexture_yuv = GL_FALSE;
 GLboolean __EGLEW_NV_stream_cross_display = GL_FALSE;
 GLboolean __EGLEW_NV_stream_cross_object = GL_FALSE;
@@ -19655,13 +20169,15 @@ GLboolean __EGLEW_NV_stream_sync = GL_FALSE;
 GLboolean __EGLEW_NV_sync = GL_FALSE;
 GLboolean __EGLEW_NV_system_time = GL_FALSE;
 GLboolean __EGLEW_NV_triple_buffer = GL_FALSE;
+GLboolean __EGLEW_QNX_image_native_buffer = GL_FALSE;
+GLboolean __EGLEW_QNX_platform_screen = GL_FALSE;
 GLboolean __EGLEW_TIZEN_image_native_buffer = GL_FALSE;
 GLboolean __EGLEW_TIZEN_image_native_surface = GL_FALSE;
 GLboolean __EGLEW_WL_bind_wayland_display = GL_FALSE;
 GLboolean __EGLEW_WL_create_wayland_buffer_from_image = GL_FALSE;
 #ifdef EGL_VERSION_1_0
 
-static GLboolean _glewInit_EGL_VERSION_1_0 ()
+static GLboolean _glewInit_EGL_VERSION_1_0 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19696,7 +20212,7 @@ static GLboolean _glewInit_EGL_VERSION_1_0 ()
 
 #ifdef EGL_VERSION_1_1
 
-static GLboolean _glewInit_EGL_VERSION_1_1 ()
+static GLboolean _glewInit_EGL_VERSION_1_1 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19712,7 +20228,7 @@ static GLboolean _glewInit_EGL_VERSION_1_1 ()
 
 #ifdef EGL_VERSION_1_2
 
-static GLboolean _glewInit_EGL_VERSION_1_2 ()
+static GLboolean _glewInit_EGL_VERSION_1_2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19729,7 +20245,7 @@ static GLboolean _glewInit_EGL_VERSION_1_2 ()
 
 #ifdef EGL_VERSION_1_4
 
-static GLboolean _glewInit_EGL_VERSION_1_4 ()
+static GLboolean _glewInit_EGL_VERSION_1_4 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19742,7 +20258,7 @@ static GLboolean _glewInit_EGL_VERSION_1_4 ()
 
 #ifdef EGL_VERSION_1_5
 
-static GLboolean _glewInit_EGL_VERSION_1_5 ()
+static GLboolean _glewInit_EGL_VERSION_1_5 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19764,7 +20280,7 @@ static GLboolean _glewInit_EGL_VERSION_1_5 ()
 
 #ifdef EGL_ANDROID_blob_cache
 
-static GLboolean _glewInit_EGL_ANDROID_blob_cache ()
+static GLboolean _glewInit_EGL_ANDROID_blob_cache (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19777,7 +20293,7 @@ static GLboolean _glewInit_EGL_ANDROID_blob_cache ()
 
 #ifdef EGL_ANDROID_create_native_client_buffer
 
-static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer ()
+static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19790,7 +20306,7 @@ static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer ()
 
 #ifdef EGL_ANDROID_get_frame_timestamps
 
-static GLboolean _glewInit_EGL_ANDROID_get_frame_timestamps ()
+static GLboolean _glewInit_EGL_ANDROID_get_frame_timestamps (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19807,7 +20323,7 @@ static GLboolean _glewInit_EGL_ANDROID_get_frame_timestamps ()
 
 #ifdef EGL_ANDROID_get_native_client_buffer
 
-static GLboolean _glewInit_EGL_ANDROID_get_native_client_buffer ()
+static GLboolean _glewInit_EGL_ANDROID_get_native_client_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19820,7 +20336,7 @@ static GLboolean _glewInit_EGL_ANDROID_get_native_client_buffer ()
 
 #ifdef EGL_ANDROID_native_fence_sync
 
-static GLboolean _glewInit_EGL_ANDROID_native_fence_sync ()
+static GLboolean _glewInit_EGL_ANDROID_native_fence_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19833,7 +20349,7 @@ static GLboolean _glewInit_EGL_ANDROID_native_fence_sync ()
 
 #ifdef EGL_ANDROID_presentation_time
 
-static GLboolean _glewInit_EGL_ANDROID_presentation_time ()
+static GLboolean _glewInit_EGL_ANDROID_presentation_time (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19846,7 +20362,7 @@ static GLboolean _glewInit_EGL_ANDROID_presentation_time ()
 
 #ifdef EGL_ANGLE_query_surface_pointer
 
-static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer ()
+static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19857,9 +20373,22 @@ static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer ()
 
 #endif /* EGL_ANGLE_query_surface_pointer */
 
+#ifdef EGL_ANGLE_sync_control_rate
+
+static GLboolean _glewInit_EGL_ANGLE_sync_control_rate (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((eglGetMscRateANGLE = (PFNEGLGETMSCRATEANGLEPROC)glewGetProcAddress((const GLubyte*)"eglGetMscRateANGLE")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* EGL_ANGLE_sync_control_rate */
+
 #ifdef EGL_EXT_client_sync
 
-static GLboolean _glewInit_EGL_EXT_client_sync ()
+static GLboolean _glewInit_EGL_EXT_client_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19872,7 +20401,7 @@ static GLboolean _glewInit_EGL_EXT_client_sync ()
 
 #ifdef EGL_EXT_compositor
 
-static GLboolean _glewInit_EGL_EXT_compositor ()
+static GLboolean _glewInit_EGL_EXT_compositor (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19891,7 +20420,7 @@ static GLboolean _glewInit_EGL_EXT_compositor ()
 
 #ifdef EGL_EXT_device_enumeration
 
-static GLboolean _glewInit_EGL_EXT_device_enumeration ()
+static GLboolean _glewInit_EGL_EXT_device_enumeration (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19902,9 +20431,22 @@ static GLboolean _glewInit_EGL_EXT_device_enumeration ()
 
 #endif /* EGL_EXT_device_enumeration */
 
+#ifdef EGL_EXT_device_persistent_id
+
+static GLboolean _glewInit_EGL_EXT_device_persistent_id (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((eglQueryDeviceBinaryEXT = (PFNEGLQUERYDEVICEBINARYEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDeviceBinaryEXT")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* EGL_EXT_device_persistent_id */
+
 #ifdef EGL_EXT_device_query
 
-static GLboolean _glewInit_EGL_EXT_device_query ()
+static GLboolean _glewInit_EGL_EXT_device_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19917,9 +20459,22 @@ static GLboolean _glewInit_EGL_EXT_device_query ()
 
 #endif /* EGL_EXT_device_query */
 
+#ifdef EGL_EXT_display_alloc
+
+static GLboolean _glewInit_EGL_EXT_display_alloc (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((eglDestroyDisplayEXT = (PFNEGLDESTROYDISPLAYEXTPROC)glewGetProcAddress((const GLubyte*)"eglDestroyDisplayEXT")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* EGL_EXT_display_alloc */
+
 #ifdef EGL_EXT_image_dma_buf_import_modifiers
 
-static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers ()
+static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19933,7 +20488,7 @@ static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers ()
 
 #ifdef EGL_EXT_output_base
 
-static GLboolean _glewInit_EGL_EXT_output_base ()
+static GLboolean _glewInit_EGL_EXT_output_base (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19953,7 +20508,7 @@ static GLboolean _glewInit_EGL_EXT_output_base ()
 
 #ifdef EGL_EXT_platform_base
 
-static GLboolean _glewInit_EGL_EXT_platform_base ()
+static GLboolean _glewInit_EGL_EXT_platform_base (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19968,7 +20523,7 @@ static GLboolean _glewInit_EGL_EXT_platform_base ()
 
 #ifdef EGL_EXT_stream_consumer_egloutput
 
-static GLboolean _glewInit_EGL_EXT_stream_consumer_egloutput ()
+static GLboolean _glewInit_EGL_EXT_stream_consumer_egloutput (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19979,9 +20534,22 @@ static GLboolean _glewInit_EGL_EXT_stream_consumer_egloutput ()
 
 #endif /* EGL_EXT_stream_consumer_egloutput */
 
+#ifdef EGL_EXT_surface_compression
+
+static GLboolean _glewInit_EGL_EXT_surface_compression (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((eglQuerySupportedCompressionRatesEXT = (PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC)glewGetProcAddress((const GLubyte*)"eglQuerySupportedCompressionRatesEXT")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* EGL_EXT_surface_compression */
+
 #ifdef EGL_EXT_swap_buffers_with_damage
 
-static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage ()
+static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -19994,7 +20562,7 @@ static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage ()
 
 #ifdef EGL_EXT_sync_reuse
 
-static GLboolean _glewInit_EGL_EXT_sync_reuse ()
+static GLboolean _glewInit_EGL_EXT_sync_reuse (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20007,7 +20575,7 @@ static GLboolean _glewInit_EGL_EXT_sync_reuse ()
 
 #ifdef EGL_HI_clientpixmap
 
-static GLboolean _glewInit_EGL_HI_clientpixmap ()
+static GLboolean _glewInit_EGL_HI_clientpixmap (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20020,7 +20588,7 @@ static GLboolean _glewInit_EGL_HI_clientpixmap ()
 
 #ifdef EGL_KHR_cl_event2
 
-static GLboolean _glewInit_EGL_KHR_cl_event2 ()
+static GLboolean _glewInit_EGL_KHR_cl_event2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20033,7 +20601,7 @@ static GLboolean _glewInit_EGL_KHR_cl_event2 ()
 
 #ifdef EGL_KHR_debug
 
-static GLboolean _glewInit_EGL_KHR_debug ()
+static GLboolean _glewInit_EGL_KHR_debug (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20048,7 +20616,7 @@ static GLboolean _glewInit_EGL_KHR_debug ()
 
 #ifdef EGL_KHR_display_reference
 
-static GLboolean _glewInit_EGL_KHR_display_reference ()
+static GLboolean _glewInit_EGL_KHR_display_reference (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20061,7 +20629,7 @@ static GLboolean _glewInit_EGL_KHR_display_reference ()
 
 #ifdef EGL_KHR_image
 
-static GLboolean _glewInit_EGL_KHR_image ()
+static GLboolean _glewInit_EGL_KHR_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20075,7 +20643,7 @@ static GLboolean _glewInit_EGL_KHR_image ()
 
 #ifdef EGL_KHR_lock_surface
 
-static GLboolean _glewInit_EGL_KHR_lock_surface ()
+static GLboolean _glewInit_EGL_KHR_lock_surface (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20089,7 +20657,7 @@ static GLboolean _glewInit_EGL_KHR_lock_surface ()
 
 #ifdef EGL_KHR_lock_surface3
 
-static GLboolean _glewInit_EGL_KHR_lock_surface3 ()
+static GLboolean _glewInit_EGL_KHR_lock_surface3 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20102,7 +20670,7 @@ static GLboolean _glewInit_EGL_KHR_lock_surface3 ()
 
 #ifdef EGL_KHR_partial_update
 
-static GLboolean _glewInit_EGL_KHR_partial_update ()
+static GLboolean _glewInit_EGL_KHR_partial_update (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20115,7 +20683,7 @@ static GLboolean _glewInit_EGL_KHR_partial_update ()
 
 #ifdef EGL_KHR_reusable_sync
 
-static GLboolean _glewInit_EGL_KHR_reusable_sync ()
+static GLboolean _glewInit_EGL_KHR_reusable_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20132,7 +20700,7 @@ static GLboolean _glewInit_EGL_KHR_reusable_sync ()
 
 #ifdef EGL_KHR_stream
 
-static GLboolean _glewInit_EGL_KHR_stream ()
+static GLboolean _glewInit_EGL_KHR_stream (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20149,7 +20717,7 @@ static GLboolean _glewInit_EGL_KHR_stream ()
 
 #ifdef EGL_KHR_stream_attrib
 
-static GLboolean _glewInit_EGL_KHR_stream_attrib ()
+static GLboolean _glewInit_EGL_KHR_stream_attrib (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20166,7 +20734,7 @@ static GLboolean _glewInit_EGL_KHR_stream_attrib ()
 
 #ifdef EGL_KHR_stream_consumer_gltexture
 
-static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture ()
+static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20181,7 +20749,7 @@ static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture ()
 
 #ifdef EGL_KHR_stream_cross_process_fd
 
-static GLboolean _glewInit_EGL_KHR_stream_cross_process_fd ()
+static GLboolean _glewInit_EGL_KHR_stream_cross_process_fd (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20195,7 +20763,7 @@ static GLboolean _glewInit_EGL_KHR_stream_cross_process_fd ()
 
 #ifdef EGL_KHR_stream_fifo
 
-static GLboolean _glewInit_EGL_KHR_stream_fifo ()
+static GLboolean _glewInit_EGL_KHR_stream_fifo (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20208,7 +20776,7 @@ static GLboolean _glewInit_EGL_KHR_stream_fifo ()
 
 #ifdef EGL_KHR_stream_producer_eglsurface
 
-static GLboolean _glewInit_EGL_KHR_stream_producer_eglsurface ()
+static GLboolean _glewInit_EGL_KHR_stream_producer_eglsurface (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20221,7 +20789,7 @@ static GLboolean _glewInit_EGL_KHR_stream_producer_eglsurface ()
 
 #ifdef EGL_KHR_swap_buffers_with_damage
 
-static GLboolean _glewInit_EGL_KHR_swap_buffers_with_damage ()
+static GLboolean _glewInit_EGL_KHR_swap_buffers_with_damage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20234,7 +20802,7 @@ static GLboolean _glewInit_EGL_KHR_swap_buffers_with_damage ()
 
 #ifdef EGL_KHR_wait_sync
 
-static GLboolean _glewInit_EGL_KHR_wait_sync ()
+static GLboolean _glewInit_EGL_KHR_wait_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20247,7 +20815,7 @@ static GLboolean _glewInit_EGL_KHR_wait_sync ()
 
 #ifdef EGL_MESA_drm_image
 
-static GLboolean _glewInit_EGL_MESA_drm_image ()
+static GLboolean _glewInit_EGL_MESA_drm_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20261,7 +20829,7 @@ static GLboolean _glewInit_EGL_MESA_drm_image ()
 
 #ifdef EGL_MESA_image_dma_buf_export
 
-static GLboolean _glewInit_EGL_MESA_image_dma_buf_export ()
+static GLboolean _glewInit_EGL_MESA_image_dma_buf_export (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20275,7 +20843,7 @@ static GLboolean _glewInit_EGL_MESA_image_dma_buf_export ()
 
 #ifdef EGL_MESA_query_driver
 
-static GLboolean _glewInit_EGL_MESA_query_driver ()
+static GLboolean _glewInit_EGL_MESA_query_driver (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20289,7 +20857,7 @@ static GLboolean _glewInit_EGL_MESA_query_driver ()
 
 #ifdef EGL_NOK_swap_region
 
-static GLboolean _glewInit_EGL_NOK_swap_region ()
+static GLboolean _glewInit_EGL_NOK_swap_region (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20302,7 +20870,7 @@ static GLboolean _glewInit_EGL_NOK_swap_region ()
 
 #ifdef EGL_NOK_swap_region2
 
-static GLboolean _glewInit_EGL_NOK_swap_region2 ()
+static GLboolean _glewInit_EGL_NOK_swap_region2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20315,7 +20883,7 @@ static GLboolean _glewInit_EGL_NOK_swap_region2 ()
 
 #ifdef EGL_NV_native_query
 
-static GLboolean _glewInit_EGL_NV_native_query ()
+static GLboolean _glewInit_EGL_NV_native_query (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20330,7 +20898,7 @@ static GLboolean _glewInit_EGL_NV_native_query ()
 
 #ifdef EGL_NV_post_sub_buffer
 
-static GLboolean _glewInit_EGL_NV_post_sub_buffer ()
+static GLboolean _glewInit_EGL_NV_post_sub_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20341,9 +20909,25 @@ static GLboolean _glewInit_EGL_NV_post_sub_buffer ()
 
 #endif /* EGL_NV_post_sub_buffer */
 
+#ifdef EGL_NV_stream_consumer_eglimage
+
+static GLboolean _glewInit_EGL_NV_stream_consumer_eglimage (void)
+{
+  GLboolean r = GL_FALSE;
+
+  r = ((eglQueryStreamConsumerEventNV = (PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamConsumerEventNV")) == NULL) || r;
+  r = ((eglStreamAcquireImageNV = (PFNEGLSTREAMACQUIREIMAGENVPROC)glewGetProcAddress((const GLubyte*)"eglStreamAcquireImageNV")) == NULL) || r;
+  r = ((eglStreamImageConsumerConnectNV = (PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC)glewGetProcAddress((const GLubyte*)"eglStreamImageConsumerConnectNV")) == NULL) || r;
+  r = ((eglStreamReleaseImageNV = (PFNEGLSTREAMRELEASEIMAGENVPROC)glewGetProcAddress((const GLubyte*)"eglStreamReleaseImageNV")) == NULL) || r;
+
+  return r;
+}
+
+#endif /* EGL_NV_stream_consumer_eglimage */
+
 #ifdef EGL_NV_stream_consumer_gltexture_yuv
 
-static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv ()
+static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20356,7 +20940,7 @@ static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv ()
 
 #ifdef EGL_NV_stream_flush
 
-static GLboolean _glewInit_EGL_NV_stream_flush ()
+static GLboolean _glewInit_EGL_NV_stream_flush (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20369,7 +20953,7 @@ static GLboolean _glewInit_EGL_NV_stream_flush ()
 
 #ifdef EGL_NV_stream_metadata
 
-static GLboolean _glewInit_EGL_NV_stream_metadata ()
+static GLboolean _glewInit_EGL_NV_stream_metadata (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20384,7 +20968,7 @@ static GLboolean _glewInit_EGL_NV_stream_metadata ()
 
 #ifdef EGL_NV_stream_reset
 
-static GLboolean _glewInit_EGL_NV_stream_reset ()
+static GLboolean _glewInit_EGL_NV_stream_reset (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20397,7 +20981,7 @@ static GLboolean _glewInit_EGL_NV_stream_reset ()
 
 #ifdef EGL_NV_stream_sync
 
-static GLboolean _glewInit_EGL_NV_stream_sync ()
+static GLboolean _glewInit_EGL_NV_stream_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20410,7 +20994,7 @@ static GLboolean _glewInit_EGL_NV_stream_sync ()
 
 #ifdef EGL_NV_sync
 
-static GLboolean _glewInit_EGL_NV_sync ()
+static GLboolean _glewInit_EGL_NV_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20428,7 +21012,7 @@ static GLboolean _glewInit_EGL_NV_sync ()
 
 #ifdef EGL_NV_system_time
 
-static GLboolean _glewInit_EGL_NV_system_time ()
+static GLboolean _glewInit_EGL_NV_system_time (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20442,7 +21026,7 @@ static GLboolean _glewInit_EGL_NV_system_time ()
 
 #ifdef EGL_WL_bind_wayland_display
 
-static GLboolean _glewInit_EGL_WL_bind_wayland_display ()
+static GLboolean _glewInit_EGL_WL_bind_wayland_display (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20457,7 +21041,7 @@ static GLboolean _glewInit_EGL_WL_bind_wayland_display ()
 
 #ifdef EGL_WL_create_wayland_buffer_from_image
 
-static GLboolean _glewInit_EGL_WL_create_wayland_buffer_from_image ()
+static GLboolean _glewInit_EGL_WL_create_wayland_buffer_from_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -20495,7 +21079,7 @@ GLenum eglewInit (EGLDisplay display)
   if (!initialize || !queryString)
     return 1;
 
-  /* query EGK version */
+  /* query EGL version */
   if (initialize(display, &major, &minor) != EGL_TRUE)
     return 1;
 
@@ -20567,6 +21151,9 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_ANDROID_recordable
   EGLEW_ANDROID_recordable = _glewSearchExtension("EGL_ANDROID_recordable", extStart, extEnd);
 #endif /* EGL_ANDROID_recordable */
+#ifdef EGL_ANDROID_telemetry_hint
+  EGLEW_ANDROID_telemetry_hint = _glewSearchExtension("EGL_ANDROID_telemetry_hint", extStart, extEnd);
+#endif /* EGL_ANDROID_telemetry_hint */
 #ifdef EGL_ANGLE_d3d_share_handle_client_buffer
   EGLEW_ANGLE_d3d_share_handle_client_buffer = _glewSearchExtension("EGL_ANGLE_d3d_share_handle_client_buffer", extStart, extEnd);
 #endif /* EGL_ANGLE_d3d_share_handle_client_buffer */
@@ -20580,6 +21167,10 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_ANGLE_surface_d3d_texture_2d_share_handle
   EGLEW_ANGLE_surface_d3d_texture_2d_share_handle = _glewSearchExtension("EGL_ANGLE_surface_d3d_texture_2d_share_handle", extStart, extEnd);
 #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */
+#ifdef EGL_ANGLE_sync_control_rate
+  EGLEW_ANGLE_sync_control_rate = _glewSearchExtension("EGL_ANGLE_sync_control_rate", extStart, extEnd);
+  if (glewExperimental || EGLEW_ANGLE_sync_control_rate) EGLEW_ANGLE_sync_control_rate = !_glewInit_EGL_ANGLE_sync_control_rate();
+#endif /* EGL_ANGLE_sync_control_rate */
 #ifdef EGL_ANGLE_window_fixed_size
   EGLEW_ANGLE_window_fixed_size = _glewSearchExtension("EGL_ANGLE_window_fixed_size", extStart, extEnd);
 #endif /* EGL_ANGLE_window_fixed_size */
@@ -20609,6 +21200,9 @@ GLenum eglewInit (EGLDisplay display)
   EGLEW_EXT_compositor = _glewSearchExtension("EGL_EXT_compositor", extStart, extEnd);
   if (glewExperimental || EGLEW_EXT_compositor) EGLEW_EXT_compositor = !_glewInit_EGL_EXT_compositor();
 #endif /* EGL_EXT_compositor */
+#ifdef EGL_EXT_config_select_group
+  EGLEW_EXT_config_select_group = _glewSearchExtension("EGL_EXT_config_select_group", extStart, extEnd);
+#endif /* EGL_EXT_config_select_group */
 #ifdef EGL_EXT_create_context_robustness
   EGLEW_EXT_create_context_robustness = _glewSearchExtension("EGL_EXT_create_context_robustness", extStart, extEnd);
 #endif /* EGL_EXT_create_context_robustness */
@@ -20618,6 +21212,9 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_EXT_device_drm
   EGLEW_EXT_device_drm = _glewSearchExtension("EGL_EXT_device_drm", extStart, extEnd);
 #endif /* EGL_EXT_device_drm */
+#ifdef EGL_EXT_device_drm_render_node
+  EGLEW_EXT_device_drm_render_node = _glewSearchExtension("EGL_EXT_device_drm_render_node", extStart, extEnd);
+#endif /* EGL_EXT_device_drm_render_node */
 #ifdef EGL_EXT_device_enumeration
   EGLEW_EXT_device_enumeration = _glewSearchExtension("EGL_EXT_device_enumeration", extStart, extEnd);
   if (glewExperimental || EGLEW_EXT_device_enumeration) EGLEW_EXT_device_enumeration = !_glewInit_EGL_EXT_device_enumeration();
@@ -20625,10 +21222,27 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_EXT_device_openwf
   EGLEW_EXT_device_openwf = _glewSearchExtension("EGL_EXT_device_openwf", extStart, extEnd);
 #endif /* EGL_EXT_device_openwf */
+#ifdef EGL_EXT_device_persistent_id
+  EGLEW_EXT_device_persistent_id = _glewSearchExtension("EGL_EXT_device_persistent_id", extStart, extEnd);
+  if (glewExperimental || EGLEW_EXT_device_persistent_id) EGLEW_EXT_device_persistent_id = !_glewInit_EGL_EXT_device_persistent_id();
+#endif /* EGL_EXT_device_persistent_id */
 #ifdef EGL_EXT_device_query
   EGLEW_EXT_device_query = _glewSearchExtension("EGL_EXT_device_query", extStart, extEnd);
   if (glewExperimental || EGLEW_EXT_device_query) EGLEW_EXT_device_query = !_glewInit_EGL_EXT_device_query();
 #endif /* EGL_EXT_device_query */
+#ifdef EGL_EXT_device_query_name
+  EGLEW_EXT_device_query_name = _glewSearchExtension("EGL_EXT_device_query_name", extStart, extEnd);
+#endif /* EGL_EXT_device_query_name */
+#ifdef EGL_EXT_display_alloc
+  EGLEW_EXT_display_alloc = _glewSearchExtension("EGL_EXT_display_alloc", extStart, extEnd);
+  if (glewExperimental || EGLEW_EXT_display_alloc) EGLEW_EXT_display_alloc = !_glewInit_EGL_EXT_display_alloc();
+#endif /* EGL_EXT_display_alloc */
+#ifdef EGL_EXT_explicit_device
+  EGLEW_EXT_explicit_device = _glewSearchExtension("EGL_EXT_explicit_device", extStart, extEnd);
+#endif /* EGL_EXT_explicit_device */
+#ifdef EGL_EXT_gl_colorspace_bt2020_hlg
+  EGLEW_EXT_gl_colorspace_bt2020_hlg = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_hlg", extStart, extEnd);
+#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */
 #ifdef EGL_EXT_gl_colorspace_bt2020_linear
   EGLEW_EXT_gl_colorspace_bt2020_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_linear", extStart, extEnd);
 #endif /* EGL_EXT_gl_colorspace_bt2020_linear */
@@ -20692,12 +21306,21 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_EXT_platform_x11
   EGLEW_EXT_platform_x11 = _glewSearchExtension("EGL_EXT_platform_x11", extStart, extEnd);
 #endif /* EGL_EXT_platform_x11 */
+#ifdef EGL_EXT_platform_xcb
+  EGLEW_EXT_platform_xcb = _glewSearchExtension("EGL_EXT_platform_xcb", extStart, extEnd);
+#endif /* EGL_EXT_platform_xcb */
+#ifdef EGL_EXT_present_opaque
+  EGLEW_EXT_present_opaque = _glewSearchExtension("EGL_EXT_present_opaque", extStart, extEnd);
+#endif /* EGL_EXT_present_opaque */
 #ifdef EGL_EXT_protected_content
   EGLEW_EXT_protected_content = _glewSearchExtension("EGL_EXT_protected_content", extStart, extEnd);
 #endif /* EGL_EXT_protected_content */
 #ifdef EGL_EXT_protected_surface
   EGLEW_EXT_protected_surface = _glewSearchExtension("EGL_EXT_protected_surface", extStart, extEnd);
 #endif /* EGL_EXT_protected_surface */
+#ifdef EGL_EXT_query_reset_notification_strategy
+  EGLEW_EXT_query_reset_notification_strategy = _glewSearchExtension("EGL_EXT_query_reset_notification_strategy", extStart, extEnd);
+#endif /* EGL_EXT_query_reset_notification_strategy */
 #ifdef EGL_EXT_stream_consumer_egloutput
   EGLEW_EXT_stream_consumer_egloutput = _glewSearchExtension("EGL_EXT_stream_consumer_egloutput", extStart, extEnd);
   if (glewExperimental || EGLEW_EXT_stream_consumer_egloutput) EGLEW_EXT_stream_consumer_egloutput = !_glewInit_EGL_EXT_stream_consumer_egloutput();
@@ -20708,6 +21331,10 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_EXT_surface_SMPTE2086_metadata
   EGLEW_EXT_surface_SMPTE2086_metadata = _glewSearchExtension("EGL_EXT_surface_SMPTE2086_metadata", extStart, extEnd);
 #endif /* EGL_EXT_surface_SMPTE2086_metadata */
+#ifdef EGL_EXT_surface_compression
+  EGLEW_EXT_surface_compression = _glewSearchExtension("EGL_EXT_surface_compression", extStart, extEnd);
+  if (glewExperimental || EGLEW_EXT_surface_compression) EGLEW_EXT_surface_compression = !_glewInit_EGL_EXT_surface_compression();
+#endif /* EGL_EXT_surface_compression */
 #ifdef EGL_EXT_swap_buffers_with_damage
   EGLEW_EXT_swap_buffers_with_damage = _glewSearchExtension("EGL_EXT_swap_buffers_with_damage", extStart, extEnd);
   if (glewExperimental || EGLEW_EXT_swap_buffers_with_damage) EGLEW_EXT_swap_buffers_with_damage = !_glewInit_EGL_EXT_swap_buffers_with_damage();
@@ -20938,6 +21565,13 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_NV_robustness_video_memory_purge
   EGLEW_NV_robustness_video_memory_purge = _glewSearchExtension("EGL_NV_robustness_video_memory_purge", extStart, extEnd);
 #endif /* EGL_NV_robustness_video_memory_purge */
+#ifdef EGL_NV_stream_consumer_eglimage
+  EGLEW_NV_stream_consumer_eglimage = _glewSearchExtension("EGL_NV_stream_consumer_eglimage", extStart, extEnd);
+  if (glewExperimental || EGLEW_NV_stream_consumer_eglimage) EGLEW_NV_stream_consumer_eglimage = !_glewInit_EGL_NV_stream_consumer_eglimage();
+#endif /* EGL_NV_stream_consumer_eglimage */
+#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib
+  EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib = _glewSearchExtension("EGL_NV_stream_consumer_eglimage_use_scanout_attrib", extStart, extEnd);
+#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */
 #ifdef EGL_NV_stream_consumer_gltexture_yuv
   EGLEW_NV_stream_consumer_gltexture_yuv = _glewSearchExtension("EGL_NV_stream_consumer_gltexture_yuv", extStart, extEnd);
   if (glewExperimental || EGLEW_NV_stream_consumer_gltexture_yuv) EGLEW_NV_stream_consumer_gltexture_yuv = !_glewInit_EGL_NV_stream_consumer_gltexture_yuv();
@@ -21011,6 +21645,12 @@ GLenum eglewInit (EGLDisplay display)
 #ifdef EGL_NV_triple_buffer
   EGLEW_NV_triple_buffer = _glewSearchExtension("EGL_NV_triple_buffer", extStart, extEnd);
 #endif /* EGL_NV_triple_buffer */
+#ifdef EGL_QNX_image_native_buffer
+  EGLEW_QNX_image_native_buffer = _glewSearchExtension("EGL_QNX_image_native_buffer", extStart, extEnd);
+#endif /* EGL_QNX_image_native_buffer */
+#ifdef EGL_QNX_platform_screen
+  EGLEW_QNX_platform_screen = _glewSearchExtension("EGL_QNX_platform_screen", extStart, extEnd);
+#endif /* EGL_QNX_platform_screen */
 #ifdef EGL_TIZEN_image_native_buffer
   EGLEW_TIZEN_image_native_buffer = _glewSearchExtension("EGL_TIZEN_image_native_buffer", extStart, extEnd);
 #endif /* EGL_TIZEN_image_native_buffer */
@@ -21239,7 +21879,7 @@ GLboolean __WGLEW_NV_video_output = GL_FALSE;
 GLboolean __WGLEW_OML_sync_control = GL_FALSE;
 #ifdef WGL_3DL_stereo_control
 
-static GLboolean _glewInit_WGL_3DL_stereo_control ()
+static GLboolean _glewInit_WGL_3DL_stereo_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21252,7 +21892,7 @@ static GLboolean _glewInit_WGL_3DL_stereo_control ()
 
 #ifdef WGL_AMD_gpu_association
 
-static GLboolean _glewInit_WGL_AMD_gpu_association ()
+static GLboolean _glewInit_WGL_AMD_gpu_association (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21273,7 +21913,7 @@ static GLboolean _glewInit_WGL_AMD_gpu_association ()
 
 #ifdef WGL_ARB_buffer_region
 
-static GLboolean _glewInit_WGL_ARB_buffer_region ()
+static GLboolean _glewInit_WGL_ARB_buffer_region (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21289,7 +21929,7 @@ static GLboolean _glewInit_WGL_ARB_buffer_region ()
 
 #ifdef WGL_ARB_create_context
 
-static GLboolean _glewInit_WGL_ARB_create_context ()
+static GLboolean _glewInit_WGL_ARB_create_context (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21302,7 +21942,7 @@ static GLboolean _glewInit_WGL_ARB_create_context ()
 
 #ifdef WGL_ARB_extensions_string
 
-static GLboolean _glewInit_WGL_ARB_extensions_string ()
+static GLboolean _glewInit_WGL_ARB_extensions_string (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21315,7 +21955,7 @@ static GLboolean _glewInit_WGL_ARB_extensions_string ()
 
 #ifdef WGL_ARB_make_current_read
 
-static GLboolean _glewInit_WGL_ARB_make_current_read ()
+static GLboolean _glewInit_WGL_ARB_make_current_read (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21329,7 +21969,7 @@ static GLboolean _glewInit_WGL_ARB_make_current_read ()
 
 #ifdef WGL_ARB_pbuffer
 
-static GLboolean _glewInit_WGL_ARB_pbuffer ()
+static GLboolean _glewInit_WGL_ARB_pbuffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21346,7 +21986,7 @@ static GLboolean _glewInit_WGL_ARB_pbuffer ()
 
 #ifdef WGL_ARB_pixel_format
 
-static GLboolean _glewInit_WGL_ARB_pixel_format ()
+static GLboolean _glewInit_WGL_ARB_pixel_format (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21361,7 +22001,7 @@ static GLboolean _glewInit_WGL_ARB_pixel_format ()
 
 #ifdef WGL_ARB_render_texture
 
-static GLboolean _glewInit_WGL_ARB_render_texture ()
+static GLboolean _glewInit_WGL_ARB_render_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21376,7 +22016,7 @@ static GLboolean _glewInit_WGL_ARB_render_texture ()
 
 #ifdef WGL_EXT_display_color_table
 
-static GLboolean _glewInit_WGL_EXT_display_color_table ()
+static GLboolean _glewInit_WGL_EXT_display_color_table (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21392,7 +22032,7 @@ static GLboolean _glewInit_WGL_EXT_display_color_table ()
 
 #ifdef WGL_EXT_extensions_string
 
-static GLboolean _glewInit_WGL_EXT_extensions_string ()
+static GLboolean _glewInit_WGL_EXT_extensions_string (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21405,7 +22045,7 @@ static GLboolean _glewInit_WGL_EXT_extensions_string ()
 
 #ifdef WGL_EXT_make_current_read
 
-static GLboolean _glewInit_WGL_EXT_make_current_read ()
+static GLboolean _glewInit_WGL_EXT_make_current_read (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21419,7 +22059,7 @@ static GLboolean _glewInit_WGL_EXT_make_current_read ()
 
 #ifdef WGL_EXT_pbuffer
 
-static GLboolean _glewInit_WGL_EXT_pbuffer ()
+static GLboolean _glewInit_WGL_EXT_pbuffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21436,7 +22076,7 @@ static GLboolean _glewInit_WGL_EXT_pbuffer ()
 
 #ifdef WGL_EXT_pixel_format
 
-static GLboolean _glewInit_WGL_EXT_pixel_format ()
+static GLboolean _glewInit_WGL_EXT_pixel_format (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21451,7 +22091,7 @@ static GLboolean _glewInit_WGL_EXT_pixel_format ()
 
 #ifdef WGL_EXT_swap_control
 
-static GLboolean _glewInit_WGL_EXT_swap_control ()
+static GLboolean _glewInit_WGL_EXT_swap_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21465,7 +22105,7 @@ static GLboolean _glewInit_WGL_EXT_swap_control ()
 
 #ifdef WGL_I3D_digital_video_control
 
-static GLboolean _glewInit_WGL_I3D_digital_video_control ()
+static GLboolean _glewInit_WGL_I3D_digital_video_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21479,7 +22119,7 @@ static GLboolean _glewInit_WGL_I3D_digital_video_control ()
 
 #ifdef WGL_I3D_gamma
 
-static GLboolean _glewInit_WGL_I3D_gamma ()
+static GLboolean _glewInit_WGL_I3D_gamma (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21495,7 +22135,7 @@ static GLboolean _glewInit_WGL_I3D_gamma ()
 
 #ifdef WGL_I3D_genlock
 
-static GLboolean _glewInit_WGL_I3D_genlock ()
+static GLboolean _glewInit_WGL_I3D_genlock (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21519,7 +22159,7 @@ static GLboolean _glewInit_WGL_I3D_genlock ()
 
 #ifdef WGL_I3D_image_buffer
 
-static GLboolean _glewInit_WGL_I3D_image_buffer ()
+static GLboolean _glewInit_WGL_I3D_image_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21535,7 +22175,7 @@ static GLboolean _glewInit_WGL_I3D_image_buffer ()
 
 #ifdef WGL_I3D_swap_frame_lock
 
-static GLboolean _glewInit_WGL_I3D_swap_frame_lock ()
+static GLboolean _glewInit_WGL_I3D_swap_frame_lock (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21551,7 +22191,7 @@ static GLboolean _glewInit_WGL_I3D_swap_frame_lock ()
 
 #ifdef WGL_I3D_swap_frame_usage
 
-static GLboolean _glewInit_WGL_I3D_swap_frame_usage ()
+static GLboolean _glewInit_WGL_I3D_swap_frame_usage (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21567,7 +22207,7 @@ static GLboolean _glewInit_WGL_I3D_swap_frame_usage ()
 
 #ifdef WGL_NV_DX_interop
 
-static GLboolean _glewInit_WGL_NV_DX_interop ()
+static GLboolean _glewInit_WGL_NV_DX_interop (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21587,7 +22227,7 @@ static GLboolean _glewInit_WGL_NV_DX_interop ()
 
 #ifdef WGL_NV_copy_image
 
-static GLboolean _glewInit_WGL_NV_copy_image ()
+static GLboolean _glewInit_WGL_NV_copy_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21600,7 +22240,7 @@ static GLboolean _glewInit_WGL_NV_copy_image ()
 
 #ifdef WGL_NV_delay_before_swap
 
-static GLboolean _glewInit_WGL_NV_delay_before_swap ()
+static GLboolean _glewInit_WGL_NV_delay_before_swap (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21613,7 +22253,7 @@ static GLboolean _glewInit_WGL_NV_delay_before_swap ()
 
 #ifdef WGL_NV_gpu_affinity
 
-static GLboolean _glewInit_WGL_NV_gpu_affinity ()
+static GLboolean _glewInit_WGL_NV_gpu_affinity (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21630,7 +22270,7 @@ static GLboolean _glewInit_WGL_NV_gpu_affinity ()
 
 #ifdef WGL_NV_present_video
 
-static GLboolean _glewInit_WGL_NV_present_video ()
+static GLboolean _glewInit_WGL_NV_present_video (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21645,7 +22285,7 @@ static GLboolean _glewInit_WGL_NV_present_video ()
 
 #ifdef WGL_NV_swap_group
 
-static GLboolean _glewInit_WGL_NV_swap_group ()
+static GLboolean _glewInit_WGL_NV_swap_group (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21663,7 +22303,7 @@ static GLboolean _glewInit_WGL_NV_swap_group ()
 
 #ifdef WGL_NV_vertex_array_range
 
-static GLboolean _glewInit_WGL_NV_vertex_array_range ()
+static GLboolean _glewInit_WGL_NV_vertex_array_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21677,7 +22317,7 @@ static GLboolean _glewInit_WGL_NV_vertex_array_range ()
 
 #ifdef WGL_NV_video_capture
 
-static GLboolean _glewInit_WGL_NV_video_capture ()
+static GLboolean _glewInit_WGL_NV_video_capture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21694,7 +22334,7 @@ static GLboolean _glewInit_WGL_NV_video_capture ()
 
 #ifdef WGL_NV_video_output
 
-static GLboolean _glewInit_WGL_NV_video_output ()
+static GLboolean _glewInit_WGL_NV_video_output (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21712,7 +22352,7 @@ static GLboolean _glewInit_WGL_NV_video_output ()
 
 #ifdef WGL_OML_sync_control
 
-static GLboolean _glewInit_WGL_OML_sync_control ()
+static GLboolean _glewInit_WGL_OML_sync_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -21750,7 +22390,7 @@ GLboolean GLEWAPIENTRY wglewGetExtension (const char* name)
   return _glewSearchExtension(name, start, end);
 }
 
-GLenum GLEWAPIENTRY wglewInit ()
+GLenum GLEWAPIENTRY wglewInit (void)
 {
   GLboolean crippled;
   const GLubyte* extStart;
@@ -22156,6 +22796,7 @@ GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE;
 GLboolean __GLXEW_EXT_create_context_es_profile = GL_FALSE;
 GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;
 GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;
+GLboolean __GLXEW_EXT_get_drawable_type = GL_FALSE;
 GLboolean __GLXEW_EXT_import_context = GL_FALSE;
 GLboolean __GLXEW_EXT_libglvnd = GL_FALSE;
 GLboolean __GLXEW_EXT_no_config_context = GL_FALSE;
@@ -22207,7 +22848,7 @@ GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;
 GLboolean __GLXEW_SUN_video_resize = GL_FALSE;
 #ifdef GLX_VERSION_1_2
 
-static GLboolean _glewInit_GLX_VERSION_1_2 ()
+static GLboolean _glewInit_GLX_VERSION_1_2 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22220,7 +22861,7 @@ static GLboolean _glewInit_GLX_VERSION_1_2 ()
 
 #ifdef GLX_VERSION_1_3
 
-static GLboolean _glewInit_GLX_VERSION_1_3 ()
+static GLboolean _glewInit_GLX_VERSION_1_3 (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22249,7 +22890,7 @@ static GLboolean _glewInit_GLX_VERSION_1_3 ()
 
 #ifdef GLX_AMD_gpu_association
 
-static GLboolean _glewInit_GLX_AMD_gpu_association ()
+static GLboolean _glewInit_GLX_AMD_gpu_association (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22270,7 +22911,7 @@ static GLboolean _glewInit_GLX_AMD_gpu_association ()
 
 #ifdef GLX_ARB_create_context
 
-static GLboolean _glewInit_GLX_ARB_create_context ()
+static GLboolean _glewInit_GLX_ARB_create_context (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22283,7 +22924,7 @@ static GLboolean _glewInit_GLX_ARB_create_context ()
 
 #ifdef GLX_ATI_render_texture
 
-static GLboolean _glewInit_GLX_ATI_render_texture ()
+static GLboolean _glewInit_GLX_ATI_render_texture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22298,7 +22939,7 @@ static GLboolean _glewInit_GLX_ATI_render_texture ()
 
 #ifdef GLX_EXT_import_context
 
-static GLboolean _glewInit_GLX_EXT_import_context ()
+static GLboolean _glewInit_GLX_EXT_import_context (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22315,7 +22956,7 @@ static GLboolean _glewInit_GLX_EXT_import_context ()
 
 #ifdef GLX_EXT_swap_control
 
-static GLboolean _glewInit_GLX_EXT_swap_control ()
+static GLboolean _glewInit_GLX_EXT_swap_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22328,7 +22969,7 @@ static GLboolean _glewInit_GLX_EXT_swap_control ()
 
 #ifdef GLX_EXT_texture_from_pixmap
 
-static GLboolean _glewInit_GLX_EXT_texture_from_pixmap ()
+static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22342,7 +22983,7 @@ static GLboolean _glewInit_GLX_EXT_texture_from_pixmap ()
 
 #ifdef GLX_MESA_agp_offset
 
-static GLboolean _glewInit_GLX_MESA_agp_offset ()
+static GLboolean _glewInit_GLX_MESA_agp_offset (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22355,7 +22996,7 @@ static GLboolean _glewInit_GLX_MESA_agp_offset ()
 
 #ifdef GLX_MESA_copy_sub_buffer
 
-static GLboolean _glewInit_GLX_MESA_copy_sub_buffer ()
+static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22368,7 +23009,7 @@ static GLboolean _glewInit_GLX_MESA_copy_sub_buffer ()
 
 #ifdef GLX_MESA_pixmap_colormap
 
-static GLboolean _glewInit_GLX_MESA_pixmap_colormap ()
+static GLboolean _glewInit_GLX_MESA_pixmap_colormap (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22381,7 +23022,7 @@ static GLboolean _glewInit_GLX_MESA_pixmap_colormap ()
 
 #ifdef GLX_MESA_query_renderer
 
-static GLboolean _glewInit_GLX_MESA_query_renderer ()
+static GLboolean _glewInit_GLX_MESA_query_renderer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22397,7 +23038,7 @@ static GLboolean _glewInit_GLX_MESA_query_renderer ()
 
 #ifdef GLX_MESA_release_buffers
 
-static GLboolean _glewInit_GLX_MESA_release_buffers ()
+static GLboolean _glewInit_GLX_MESA_release_buffers (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22410,7 +23051,7 @@ static GLboolean _glewInit_GLX_MESA_release_buffers ()
 
 #ifdef GLX_MESA_set_3dfx_mode
 
-static GLboolean _glewInit_GLX_MESA_set_3dfx_mode ()
+static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22423,7 +23064,7 @@ static GLboolean _glewInit_GLX_MESA_set_3dfx_mode ()
 
 #ifdef GLX_MESA_swap_control
 
-static GLboolean _glewInit_GLX_MESA_swap_control ()
+static GLboolean _glewInit_GLX_MESA_swap_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22437,7 +23078,7 @@ static GLboolean _glewInit_GLX_MESA_swap_control ()
 
 #ifdef GLX_NV_copy_buffer
 
-static GLboolean _glewInit_GLX_NV_copy_buffer ()
+static GLboolean _glewInit_GLX_NV_copy_buffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22451,7 +23092,7 @@ static GLboolean _glewInit_GLX_NV_copy_buffer ()
 
 #ifdef GLX_NV_copy_image
 
-static GLboolean _glewInit_GLX_NV_copy_image ()
+static GLboolean _glewInit_GLX_NV_copy_image (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22464,7 +23105,7 @@ static GLboolean _glewInit_GLX_NV_copy_image ()
 
 #ifdef GLX_NV_delay_before_swap
 
-static GLboolean _glewInit_GLX_NV_delay_before_swap ()
+static GLboolean _glewInit_GLX_NV_delay_before_swap (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22477,7 +23118,7 @@ static GLboolean _glewInit_GLX_NV_delay_before_swap ()
 
 #ifdef GLX_NV_present_video
 
-static GLboolean _glewInit_GLX_NV_present_video ()
+static GLboolean _glewInit_GLX_NV_present_video (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22491,7 +23132,7 @@ static GLboolean _glewInit_GLX_NV_present_video ()
 
 #ifdef GLX_NV_swap_group
 
-static GLboolean _glewInit_GLX_NV_swap_group ()
+static GLboolean _glewInit_GLX_NV_swap_group (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22509,7 +23150,7 @@ static GLboolean _glewInit_GLX_NV_swap_group ()
 
 #ifdef GLX_NV_vertex_array_range
 
-static GLboolean _glewInit_GLX_NV_vertex_array_range ()
+static GLboolean _glewInit_GLX_NV_vertex_array_range (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22523,7 +23164,7 @@ static GLboolean _glewInit_GLX_NV_vertex_array_range ()
 
 #ifdef GLX_NV_video_capture
 
-static GLboolean _glewInit_GLX_NV_video_capture ()
+static GLboolean _glewInit_GLX_NV_video_capture (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22540,7 +23181,7 @@ static GLboolean _glewInit_GLX_NV_video_capture ()
 
 #ifdef GLX_NV_video_out
 
-static GLboolean _glewInit_GLX_NV_video_out ()
+static GLboolean _glewInit_GLX_NV_video_out (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22558,7 +23199,7 @@ static GLboolean _glewInit_GLX_NV_video_out ()
 
 #ifdef GLX_OML_sync_control
 
-static GLboolean _glewInit_GLX_OML_sync_control ()
+static GLboolean _glewInit_GLX_OML_sync_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22575,7 +23216,7 @@ static GLboolean _glewInit_GLX_OML_sync_control ()
 
 #ifdef GLX_SGIX_fbconfig
 
-static GLboolean _glewInit_GLX_SGIX_fbconfig ()
+static GLboolean _glewInit_GLX_SGIX_fbconfig (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22593,7 +23234,7 @@ static GLboolean _glewInit_GLX_SGIX_fbconfig ()
 
 #ifdef GLX_SGIX_hyperpipe
 
-static GLboolean _glewInit_GLX_SGIX_hyperpipe ()
+static GLboolean _glewInit_GLX_SGIX_hyperpipe (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22613,7 +23254,7 @@ static GLboolean _glewInit_GLX_SGIX_hyperpipe ()
 
 #ifdef GLX_SGIX_pbuffer
 
-static GLboolean _glewInit_GLX_SGIX_pbuffer ()
+static GLboolean _glewInit_GLX_SGIX_pbuffer (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22630,7 +23271,7 @@ static GLboolean _glewInit_GLX_SGIX_pbuffer ()
 
 #ifdef GLX_SGIX_swap_barrier
 
-static GLboolean _glewInit_GLX_SGIX_swap_barrier ()
+static GLboolean _glewInit_GLX_SGIX_swap_barrier (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22644,7 +23285,7 @@ static GLboolean _glewInit_GLX_SGIX_swap_barrier ()
 
 #ifdef GLX_SGIX_swap_group
 
-static GLboolean _glewInit_GLX_SGIX_swap_group ()
+static GLboolean _glewInit_GLX_SGIX_swap_group (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22657,7 +23298,7 @@ static GLboolean _glewInit_GLX_SGIX_swap_group ()
 
 #ifdef GLX_SGIX_video_resize
 
-static GLboolean _glewInit_GLX_SGIX_video_resize ()
+static GLboolean _glewInit_GLX_SGIX_video_resize (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22674,7 +23315,7 @@ static GLboolean _glewInit_GLX_SGIX_video_resize ()
 
 #ifdef GLX_SGI_cushion
 
-static GLboolean _glewInit_GLX_SGI_cushion ()
+static GLboolean _glewInit_GLX_SGI_cushion (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22687,7 +23328,7 @@ static GLboolean _glewInit_GLX_SGI_cushion ()
 
 #ifdef GLX_SGI_make_current_read
 
-static GLboolean _glewInit_GLX_SGI_make_current_read ()
+static GLboolean _glewInit_GLX_SGI_make_current_read (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22701,7 +23342,7 @@ static GLboolean _glewInit_GLX_SGI_make_current_read ()
 
 #ifdef GLX_SGI_swap_control
 
-static GLboolean _glewInit_GLX_SGI_swap_control ()
+static GLboolean _glewInit_GLX_SGI_swap_control (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22714,7 +23355,7 @@ static GLboolean _glewInit_GLX_SGI_swap_control ()
 
 #ifdef GLX_SGI_video_sync
 
-static GLboolean _glewInit_GLX_SGI_video_sync ()
+static GLboolean _glewInit_GLX_SGI_video_sync (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22728,7 +23369,7 @@ static GLboolean _glewInit_GLX_SGI_video_sync ()
 
 #ifdef GLX_SUN_get_transparent_index
 
-static GLboolean _glewInit_GLX_SUN_get_transparent_index ()
+static GLboolean _glewInit_GLX_SUN_get_transparent_index (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22741,7 +23382,7 @@ static GLboolean _glewInit_GLX_SUN_get_transparent_index ()
 
 #ifdef GLX_SUN_video_resize
 
-static GLboolean _glewInit_GLX_SUN_video_resize ()
+static GLboolean _glewInit_GLX_SUN_video_resize (void)
 {
   GLboolean r = GL_FALSE;
 
@@ -22767,7 +23408,7 @@ GLboolean glxewGetExtension (const char* name)
   return _glewSearchExtension(name, start, end);
 }
 
-GLenum glxewInit ()
+GLenum glxewInit (void)
 {
   Display* display;
   int major, minor;
@@ -22882,6 +23523,9 @@ GLenum glxewInit ()
 #ifdef GLX_EXT_framebuffer_sRGB
   GLXEW_EXT_framebuffer_sRGB = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd);
 #endif /* GLX_EXT_framebuffer_sRGB */
+#ifdef GLX_EXT_get_drawable_type
+  GLXEW_EXT_get_drawable_type = _glewSearchExtension("GLX_EXT_get_drawable_type", extStart, extEnd);
+#endif /* GLX_EXT_get_drawable_type */
 #ifdef GLX_EXT_import_context
   GLXEW_EXT_import_context = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd);
   if (glewExperimental || GLXEW_EXT_import_context) GLXEW_EXT_import_context = !_glewInit_GLX_EXT_import_context();
@@ -23076,6 +23720,7 @@ const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error)
     (const GLubyte*)"Missing GL version",
     (const GLubyte*)"GL 1.1 and up are not supported",
     (const GLubyte*)"GLX 1.2 and up are not supported",
+    (const GLubyte*)"No GLX display",
     (const GLubyte*)"Unknown error"
   };
   const size_t max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;
@@ -23087,10 +23732,10 @@ const GLubyte * GLEWAPIENTRY glewGetString (GLenum name)
   static const GLubyte* _glewString[] =
   {
     (const GLubyte*)NULL,
-    (const GLubyte*)"2.2.0",
-    (const GLubyte*)"2",
+    (const GLubyte*)"2.3.1",
     (const GLubyte*)"2",
-    (const GLubyte*)"0"
+    (const GLubyte*)"3",
+    (const GLubyte*)"1"
   };
   const size_t max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;
   return _glewString[(size_t)name > max_string ? 0 : (size_t)name];
@@ -23133,6 +23778,17 @@ int __stdcall DllMainCRTStartup(void* instance, unsigned reason, void* reserved)
   return 1;
 }
 #endif
+
+#if defined(_WIN32) && defined(GLEW_BUILD) && defined(__clang__)
+/* Windows mingw clang requires a DLL entry point */
+int __stdcall _DllMainCRTStartup(void* instance, unsigned reason, void* reserved)
+{
+  (void) instance;
+  (void) reason;
+  (void) reserved;
+  return 1;
+}
+#endif
 GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
 {
   const GLubyte* pos = (const GLubyte*)name;
@@ -25090,6 +25746,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_ARM_shader_core_properties
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_core_properties", 22))
+        {
+          ret = GLEW_ARM_shader_core_properties;
+          continue;
+        }
+#endif
 #ifdef GL_ARM_shader_framebuffer_fetch
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24))
         {
@@ -25319,6 +25982,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_EGL_image_storage_compression
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_storage_compression", 29))
+        {
+          ret = GLEW_EXT_EGL_image_storage_compression;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_EGL_sync
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_sync", 8))
         {
@@ -25662,6 +26332,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_fragment_shading_rate
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shading_rate", 21))
+        {
+          ret = GLEW_EXT_fragment_shading_rate;
+          continue;
+        }
+#endif
+#ifdef GL_EXT_fragment_shading_rate_attachment
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shading_rate_attachment", 32))
+        {
+          ret = GLEW_EXT_fragment_shading_rate_attachment;
+          continue;
+        }
+#endif
+#ifdef GL_EXT_fragment_shading_rate_primitive
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shading_rate_primitive", 31))
+        {
+          ret = GLEW_EXT_fragment_shading_rate_primitive;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_framebuffer_blit
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))
         {
@@ -25669,6 +26360,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_framebuffer_blit_layers
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit_layers", 23))
+        {
+          ret = GLEW_EXT_framebuffer_blit_layers;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_framebuffer_multisample
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))
         {
@@ -25816,6 +26514,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_mesh_shader
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_shader", 11))
+        {
+          ret = GLEW_EXT_mesh_shader;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_misc_attribute
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))
         {
@@ -26096,6 +26801,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_separate_depth_stencil
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_depth_stencil", 22))
+        {
+          ret = GLEW_EXT_separate_depth_stencil;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_separate_shader_objects
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
         {
@@ -26110,6 +26822,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_shader_clock
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_clock", 12))
+        {
+          ret = GLEW_EXT_shader_clock;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_shader_framebuffer_fetch
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24))
         {
@@ -26187,6 +26906,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_shader_realtime_clock
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_realtime_clock", 21))
+        {
+          ret = GLEW_EXT_shader_realtime_clock;
+          continue;
+        }
+#endif
+#ifdef GL_EXT_shader_samples_identical
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_samples_identical", 24))
+        {
+          ret = GLEW_EXT_shader_samples_identical;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_shader_texture_lod
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
         {
@@ -26194,6 +26927,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_shader_texture_samples
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_samples", 22))
+        {
+          ret = GLEW_EXT_shader_texture_samples;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_shadow_funcs
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))
         {
@@ -26579,6 +27319,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_EXT_texture_storage_compression
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage_compression", 27))
+        {
+          ret = GLEW_EXT_texture_storage_compression;
+          continue;
+        }
+#endif
 #ifdef GL_EXT_texture_swizzle
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
         {
@@ -26741,6 +27488,23 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           ret = GLEW_HP_texture_lighting;
           continue;
         }
+#endif
+      }
+      if (_glewStrSame2(&pos, &len, (const GLubyte*)"HUAWEI_", 7))
+      {
+#ifdef GL_HUAWEI_program_binary
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary", 14))
+        {
+          ret = GLEW_HUAWEI_program_binary;
+          continue;
+        }
+#endif
+#ifdef GL_HUAWEI_shader_binary
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_binary", 13))
+        {
+          ret = GLEW_HUAWEI_shader_binary;
+          continue;
+        }
 #endif
       }
       if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))
@@ -26818,6 +27582,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_IMG_pvric_end_to_end_signature
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"pvric_end_to_end_signature", 26))
+        {
+          ret = GLEW_IMG_pvric_end_to_end_signature;
+          continue;
+        }
+#endif
 #ifdef GL_IMG_read_format
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11))
         {
@@ -26859,6 +27630,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           ret = GLEW_IMG_texture_filter_cubic;
           continue;
         }
+#endif
+#ifdef GL_IMG_tile_region_protection
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"tile_region_protection", 22))
+        {
+          ret = GLEW_IMG_tile_region_protection;
+          continue;
+        }
 #endif
       }
       if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))
@@ -27053,6 +27831,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
       }
       if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
       {
+#ifdef GL_MESA_bgra
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))
+        {
+          ret = GLEW_MESA_bgra;
+          continue;
+        }
+#endif
+#ifdef GL_MESA_framebuffer_flip_x
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_flip_x", 18))
+        {
+          ret = GLEW_MESA_framebuffer_flip_x;
+          continue;
+        }
+#endif
 #ifdef GL_MESA_framebuffer_flip_y
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_flip_y", 18))
         {
@@ -27060,6 +27852,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_MESA_framebuffer_swap_xy
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_swap_xy", 19))
+        {
+          ret = GLEW_MESA_framebuffer_swap_xy;
+          continue;
+        }
+#endif
 #ifdef GL_MESA_pack_invert
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))
         {
@@ -27088,6 +27887,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_MESA_texture_const_bandwidth
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_const_bandwidth", 23))
+        {
+          ret = GLEW_MESA_texture_const_bandwidth;
+          continue;
+        }
+#endif
 #ifdef GL_MESA_tile_raster_order
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"tile_raster_order", 17))
         {
@@ -27633,6 +28439,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_NV_memory_object_sparse
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object_sparse", 20))
+        {
+          ret = GLEW_NV_memory_object_sparse;
+          continue;
+        }
+#endif
 #ifdef GL_NV_mesh_shader
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_shader", 11))
         {
@@ -27773,6 +28586,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_NV_primitive_shading_rate
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_shading_rate", 22))
+        {
+          ret = GLEW_NV_primitive_shading_rate;
+          continue;
+        }
+#endif
 #ifdef GL_NV_query_resource_tag
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_resource_tag", 18))
         {
@@ -28116,6 +28936,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_NV_timeline_semaphore
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"timeline_semaphore", 18))
+        {
+          ret = GLEW_NV_timeline_semaphore;
+          continue;
+        }
+#endif
 #ifdef GL_NV_transform_feedback
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))
         {
@@ -28130,6 +28957,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_NV_uniform_buffer_std430_layout
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_std430_layout", 28))
+        {
+          ret = GLEW_NV_uniform_buffer_std430_layout;
+          continue;
+        }
+#endif
 #ifdef GL_NV_uniform_buffer_unified_memory
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_unified_memory", 29))
         {
@@ -28796,6 +29630,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_QCOM_frame_extrapolation
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_extrapolation", 19))
+        {
+          ret = GLEW_QCOM_frame_extrapolation;
+          continue;
+        }
+#endif
 #ifdef GL_QCOM_framebuffer_foveated
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_foveated", 20))
         {
@@ -28803,6 +29644,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_QCOM_motion_estimation
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"motion_estimation", 17))
+        {
+          ret = GLEW_QCOM_motion_estimation;
+          continue;
+        }
+#endif
 #ifdef GL_QCOM_perfmon_global_mode
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"perfmon_global_mode", 19))
         {
@@ -28810,6 +29658,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_QCOM_render_sRGB_R8_RG8
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_sRGB_R8_RG8", 18))
+        {
+          ret = GLEW_QCOM_render_sRGB_R8_RG8;
+          continue;
+        }
+#endif
+#ifdef GL_QCOM_render_shared_exponent
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_shared_exponent", 22))
+        {
+          ret = GLEW_QCOM_render_shared_exponent;
+          continue;
+        }
+#endif
 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_noncoherent", 36))
         {
@@ -28824,6 +29686,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_QCOM_shading_rate
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_rate", 12))
+        {
+          ret = GLEW_QCOM_shading_rate;
+          continue;
+        }
+#endif
 #ifdef GL_QCOM_texture_foveated
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated", 16))
         {
@@ -28831,6 +29700,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_QCOM_texture_foveated2
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated2", 17))
+        {
+          ret = GLEW_QCOM_texture_foveated2;
+          continue;
+        }
+#endif
 #ifdef GL_QCOM_texture_foveated_subsampled_layout
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated_subsampled_layout", 34))
         {
@@ -28838,6 +29714,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GL_QCOM_texture_lod_bias
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))
+        {
+          ret = GLEW_QCOM_texture_lod_bias;
+          continue;
+        }
+#endif
 #ifdef GL_QCOM_tiled_rendering
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"tiled_rendering", 15))
         {
@@ -28851,6 +29734,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name)
           ret = GLEW_QCOM_writeonly_rendering;
           continue;
         }
+#endif
+#ifdef GL_QCOM_ycbcr_degamma
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_degamma", 13))
+        {
+          ret = GLEW_QCOM_ycbcr_degamma;
+          continue;
+        }
 #endif
       }
       if (_glewStrSame2(&pos, &len, (const GLubyte*)"REGAL_", 6))
@@ -30431,6 +31321,13 @@ GLboolean glxewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef GLX_EXT_get_drawable_type
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_drawable_type", 17))
+        {
+          ret = GLXEW_EXT_get_drawable_type;
+          continue;
+        }
+#endif
 #ifdef GLX_EXT_import_context
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))
         {
@@ -30939,6 +31836,13 @@ GLboolean eglewIsSupported (const char* name)
           ret = EGLEW_ANDROID_recordable;
           continue;
         }
+#endif
+#ifdef EGL_ANDROID_telemetry_hint
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"telemetry_hint", 14))
+        {
+          ret = EGLEW_ANDROID_telemetry_hint;
+          continue;
+        }
 #endif
       }
       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANGLE_", 6))
@@ -30971,6 +31875,13 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_ANGLE_sync_control_rate
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control_rate", 17))
+        {
+          ret = EGLEW_ANGLE_sync_control_rate;
+          continue;
+        }
+#endif
 #ifdef EGL_ANGLE_window_fixed_size
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_fixed_size", 17))
         {
@@ -31040,6 +31951,13 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_EXT_config_select_group
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"config_select_group", 19))
+        {
+          ret = EGLEW_EXT_config_select_group;
+          continue;
+        }
+#endif
 #ifdef EGL_EXT_create_context_robustness
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))
         {
@@ -31061,6 +31979,13 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_EXT_device_drm_render_node
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_drm_render_node", 22))
+        {
+          ret = EGLEW_EXT_device_drm_render_node;
+          continue;
+        }
+#endif
 #ifdef EGL_EXT_device_enumeration
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_enumeration", 18))
         {
@@ -31075,6 +32000,13 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_EXT_device_persistent_id
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_persistent_id", 20))
+        {
+          ret = EGLEW_EXT_device_persistent_id;
+          continue;
+        }
+#endif
 #ifdef EGL_EXT_device_query
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_query", 12))
         {
@@ -31082,6 +32014,34 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_EXT_device_query_name
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"device_query_name", 17))
+        {
+          ret = EGLEW_EXT_device_query_name;
+          continue;
+        }
+#endif
+#ifdef EGL_EXT_display_alloc
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_alloc", 13))
+        {
+          ret = EGLEW_EXT_display_alloc;
+          continue;
+        }
+#endif
+#ifdef EGL_EXT_explicit_device
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_device", 15))
+        {
+          ret = EGLEW_EXT_explicit_device;
+          continue;
+        }
+#endif
+#ifdef EGL_EXT_gl_colorspace_bt2020_hlg
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_hlg", 24))
+        {
+          ret = EGLEW_EXT_gl_colorspace_bt2020_hlg;
+          continue;
+        }
+#endif
 #ifdef EGL_EXT_gl_colorspace_bt2020_linear
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_linear", 27))
         {
@@ -31222,6 +32182,20 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_EXT_platform_xcb
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_xcb", 12))
+        {
+          ret = EGLEW_EXT_platform_xcb;
+          continue;
+        }
+#endif
+#ifdef EGL_EXT_present_opaque
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_opaque", 14))
+        {
+          ret = EGLEW_EXT_present_opaque;
+          continue;
+        }
+#endif
 #ifdef EGL_EXT_protected_content
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"protected_content", 17))
         {
@@ -31236,6 +32210,13 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_EXT_query_reset_notification_strategy
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_reset_notification_strategy", 33))
+        {
+          ret = EGLEW_EXT_query_reset_notification_strategy;
+          continue;
+        }
+#endif
 #ifdef EGL_EXT_stream_consumer_egloutput
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_egloutput", 25))
         {
@@ -31257,6 +32238,13 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_EXT_surface_compression
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"surface_compression", 19))
+        {
+          ret = EGLEW_EXT_surface_compression;
+          continue;
+        }
+#endif
 #ifdef EGL_EXT_swap_buffers_with_damage
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_buffers_with_damage", 24))
         {
@@ -31751,6 +32739,20 @@ GLboolean eglewIsSupported (const char* name)
           continue;
         }
 #endif
+#ifdef EGL_NV_stream_consumer_eglimage
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_eglimage", 24))
+        {
+          ret = EGLEW_NV_stream_consumer_eglimage;
+          continue;
+        }
+#endif
+#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_eglimage_use_scanout_attrib", 43))
+        {
+          ret = EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib;
+          continue;
+        }
+#endif
 #ifdef EGL_NV_stream_consumer_gltexture_yuv
         if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_gltexture_yuv", 29))
         {
@@ -31904,6 +32906,23 @@ GLboolean eglewIsSupported (const char* name)
           ret = EGLEW_NV_triple_buffer;
           continue;
         }
+#endif
+      }
+      if (_glewStrSame2(&pos, &len, (const GLubyte*)"QNX_", 4))
+      {
+#ifdef EGL_QNX_image_native_buffer
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_native_buffer", 19))
+        {
+          ret = EGLEW_QNX_image_native_buffer;
+          continue;
+        }
+#endif
+#ifdef EGL_QNX_platform_screen
+        if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_screen", 15))
+        {
+          ret = EGLEW_QNX_platform_screen;
+          continue;
+        }
 #endif
       }
       if (_glewStrSame2(&pos, &len, (const GLubyte*)"TIZEN_", 6))
diff --git a/3rdparty/glew/src/glewinfo.c b/3rdparty/glew/src/glewinfo.c
index bcfa43f8361..a32b90bd728 100644
--- a/3rdparty/glew/src/glewinfo.c
+++ b/3rdparty/glew/src/glewinfo.c
@@ -1,6 +1,6 @@
 /*
 ** The OpenGL Extension Wrangler Library
-** Copyright (C) 2008-2019, Nigel Stewart <nigels[]users sourceforge net>
+** Copyright (C) 2008-2025, Nigel Stewart <nigels[]nigels com>
 ** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>
 ** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>
 ** Copyright (C) 2002, Lev Povalahev
@@ -37,7 +37,12 @@
 #if defined(GLEW_EGL)
 #include <GL/eglew.h>
 #elif defined(GLEW_OSMESA)
+#ifndef GLAPI
 #define GLAPI extern
+#endif
+#ifndef APIENTRY
+#define APIENTRY
+#endif
 #include <GL/osmesa.h>
 #elif defined(_WIN32)
 #include <GL/wglew.h>
@@ -81,7 +86,7 @@ GLboolean glewCreateContext (struct createParams *params);
 
 GLboolean glewParseArgs (int argc, char** argv, struct createParams *);
 
-void glewDestroyContext ();
+void glewDestroyContext (void);
 
 /* ------------------------------------------------------------------------- */
 
@@ -2648,6 +2653,7 @@ static void _glewInfo_GL_ARB_sample_locations (void)
 {
   GLboolean fi = glewPrintExt("GL_ARB_sample_locations", GLEW_ARB_sample_locations, glewIsSupported("GL_ARB_sample_locations"), glewGetExtension("GL_ARB_sample_locations"));
 
+  glewInfoFunc(fi, "glEvaluateDepthValuesARB", glEvaluateDepthValuesARB == NULL);
   glewInfoFunc(fi, "glFramebufferSampleLocationsfvARB", glFramebufferSampleLocationsfvARB == NULL);
   glewInfoFunc(fi, "glNamedFramebufferSampleLocationsfvARB", glNamedFramebufferSampleLocationsfvARB == NULL);
 }
@@ -3873,6 +3879,17 @@ static void _glewInfo_GL_ARM_rgba8 (void)
 
 #endif /* GL_ARM_rgba8 */
 
+#ifdef GL_ARM_shader_core_properties
+
+static void _glewInfo_GL_ARM_shader_core_properties (void)
+{
+  GLboolean fi = glewPrintExt("GL_ARM_shader_core_properties", GLEW_ARM_shader_core_properties, glewIsSupported("GL_ARM_shader_core_properties"), glewGetExtension("GL_ARM_shader_core_properties"));
+
+  glewInfoFunc(fi, "glMaxActiveShaderCoresARM", glMaxActiveShaderCoresARM == NULL);
+}
+
+#endif /* GL_ARM_shader_core_properties */
+
 #ifdef GL_ARM_shader_framebuffer_fetch
 
 static void _glewInfo_GL_ARM_shader_framebuffer_fetch (void)
@@ -4253,6 +4270,15 @@ static void _glewInfo_GL_EXT_EGL_image_storage (void)
 
 #endif /* GL_EXT_EGL_image_storage */
 
+#ifdef GL_EXT_EGL_image_storage_compression
+
+static void _glewInfo_GL_EXT_EGL_image_storage_compression (void)
+{
+  glewPrintExt("GL_EXT_EGL_image_storage_compression", GLEW_EXT_EGL_image_storage_compression, glewIsSupported("GL_EXT_EGL_image_storage_compression"), glewGetExtension("GL_EXT_EGL_image_storage_compression"));
+}
+
+#endif /* GL_EXT_EGL_image_storage_compression */
+
 #ifdef GL_EXT_EGL_sync
 
 static void _glewInfo_GL_EXT_EGL_sync (void)
@@ -4397,7 +4423,6 @@ static void _glewInfo_GL_EXT_buffer_storage (void)
   GLboolean fi = glewPrintExt("GL_EXT_buffer_storage", GLEW_EXT_buffer_storage, glewIsSupported("GL_EXT_buffer_storage"), glewGetExtension("GL_EXT_buffer_storage"));
 
   glewInfoFunc(fi, "glBufferStorageEXT", glBufferStorageEXT == NULL);
-  glewInfoFunc(fi, "glNamedBufferStorageEXT", glNamedBufferStorageEXT == NULL);
 }
 
 #endif /* GL_EXT_buffer_storage */
@@ -4765,6 +4790,7 @@ static void _glewInfo_GL_EXT_direct_state_access (void)
   glewInfoFunc(fi, "glMultiTexSubImage2DEXT", glMultiTexSubImage2DEXT == NULL);
   glewInfoFunc(fi, "glMultiTexSubImage3DEXT", glMultiTexSubImage3DEXT == NULL);
   glewInfoFunc(fi, "glNamedBufferDataEXT", glNamedBufferDataEXT == NULL);
+  glewInfoFunc(fi, "glNamedBufferStorageEXT", glNamedBufferStorageEXT == NULL);
   glewInfoFunc(fi, "glNamedBufferSubDataEXT", glNamedBufferSubDataEXT == NULL);
   glewInfoFunc(fi, "glNamedCopyBufferSubDataEXT", glNamedCopyBufferSubDataEXT == NULL);
   glewInfoFunc(fi, "glNamedFramebufferRenderbufferEXT", glNamedFramebufferRenderbufferEXT == NULL);
@@ -4827,6 +4853,7 @@ static void _glewInfo_GL_EXT_direct_state_access (void)
   glewInfoFunc(fi, "glTextureImage1DEXT", glTextureImage1DEXT == NULL);
   glewInfoFunc(fi, "glTextureImage2DEXT", glTextureImage2DEXT == NULL);
   glewInfoFunc(fi, "glTextureImage3DEXT", glTextureImage3DEXT == NULL);
+  glewInfoFunc(fi, "glTexturePageCommitmentEXT", glTexturePageCommitmentEXT == NULL);
   glewInfoFunc(fi, "glTextureParameterIivEXT", glTextureParameterIivEXT == NULL);
   glewInfoFunc(fi, "glTextureParameterIuivEXT", glTextureParameterIuivEXT == NULL);
   glewInfoFunc(fi, "glTextureParameterfEXT", glTextureParameterfEXT == NULL);
@@ -5052,6 +5079,38 @@ static void _glewInfo_GL_EXT_fragment_lighting (void)
 
 #endif /* GL_EXT_fragment_lighting */
 
+#ifdef GL_EXT_fragment_shading_rate
+
+static void _glewInfo_GL_EXT_fragment_shading_rate (void)
+{
+  GLboolean fi = glewPrintExt("GL_EXT_fragment_shading_rate", GLEW_EXT_fragment_shading_rate, glewIsSupported("GL_EXT_fragment_shading_rate"), glewGetExtension("GL_EXT_fragment_shading_rate"));
+
+  glewInfoFunc(fi, "glFramebufferShadingRateEXT", glFramebufferShadingRateEXT == NULL);
+  glewInfoFunc(fi, "glGetFragmentShadingRatesEXT", glGetFragmentShadingRatesEXT == NULL);
+  glewInfoFunc(fi, "glShadingRateCombinerOpsEXT", glShadingRateCombinerOpsEXT == NULL);
+  glewInfoFunc(fi, "glShadingRateEXT", glShadingRateEXT == NULL);
+}
+
+#endif /* GL_EXT_fragment_shading_rate */
+
+#ifdef GL_EXT_fragment_shading_rate_attachment
+
+static void _glewInfo_GL_EXT_fragment_shading_rate_attachment (void)
+{
+  glewPrintExt("GL_EXT_fragment_shading_rate_attachment", GLEW_EXT_fragment_shading_rate_attachment, glewIsSupported("GL_EXT_fragment_shading_rate_attachment"), glewGetExtension("GL_EXT_fragment_shading_rate_attachment"));
+}
+
+#endif /* GL_EXT_fragment_shading_rate_attachment */
+
+#ifdef GL_EXT_fragment_shading_rate_primitive
+
+static void _glewInfo_GL_EXT_fragment_shading_rate_primitive (void)
+{
+  glewPrintExt("GL_EXT_fragment_shading_rate_primitive", GLEW_EXT_fragment_shading_rate_primitive, glewIsSupported("GL_EXT_fragment_shading_rate_primitive"), glewGetExtension("GL_EXT_fragment_shading_rate_primitive"));
+}
+
+#endif /* GL_EXT_fragment_shading_rate_primitive */
+
 #ifdef GL_EXT_framebuffer_blit
 
 static void _glewInfo_GL_EXT_framebuffer_blit (void)
@@ -5063,6 +5122,18 @@ static void _glewInfo_GL_EXT_framebuffer_blit (void)
 
 #endif /* GL_EXT_framebuffer_blit */
 
+#ifdef GL_EXT_framebuffer_blit_layers
+
+static void _glewInfo_GL_EXT_framebuffer_blit_layers (void)
+{
+  GLboolean fi = glewPrintExt("GL_EXT_framebuffer_blit_layers", GLEW_EXT_framebuffer_blit_layers, glewIsSupported("GL_EXT_framebuffer_blit_layers"), glewGetExtension("GL_EXT_framebuffer_blit_layers"));
+
+  glewInfoFunc(fi, "glBlitFramebufferLayerEXT", glBlitFramebufferLayerEXT == NULL);
+  glewInfoFunc(fi, "glBlitFramebufferLayersEXT", glBlitFramebufferLayersEXT == NULL);
+}
+
+#endif /* GL_EXT_framebuffer_blit_layers */
+
 #ifdef GL_EXT_framebuffer_multisample
 
 static void _glewInfo_GL_EXT_framebuffer_multisample (void)
@@ -5363,6 +5434,20 @@ static void _glewInfo_GL_EXT_memory_object_win32 (void)
 
 #endif /* GL_EXT_memory_object_win32 */
 
+#ifdef GL_EXT_mesh_shader
+
+static void _glewInfo_GL_EXT_mesh_shader (void)
+{
+  GLboolean fi = glewPrintExt("GL_EXT_mesh_shader", GLEW_EXT_mesh_shader, glewIsSupported("GL_EXT_mesh_shader"), glewGetExtension("GL_EXT_mesh_shader"));
+
+  glewInfoFunc(fi, "glDrawMeshTasksEXT", glDrawMeshTasksEXT == NULL);
+  glewInfoFunc(fi, "glDrawMeshTasksIndirectEXT", glDrawMeshTasksIndirectEXT == NULL);
+  glewInfoFunc(fi, "glMultiDrawMeshTasksIndirectCountEXT", glMultiDrawMeshTasksIndirectCountEXT == NULL);
+  glewInfoFunc(fi, "glMultiDrawMeshTasksIndirectEXT", glMultiDrawMeshTasksIndirectEXT == NULL);
+}
+
+#endif /* GL_EXT_mesh_shader */
+
 #ifdef GL_EXT_misc_attribute
 
 static void _glewInfo_GL_EXT_misc_attribute (void)
@@ -5700,6 +5785,7 @@ static void _glewInfo_GL_EXT_robustness (void)
 {
   GLboolean fi = glewPrintExt("GL_EXT_robustness", GLEW_EXT_robustness, glewIsSupported("GL_EXT_robustness"), glewGetExtension("GL_EXT_robustness"));
 
+  glewInfoFunc(fi, "glGetGraphicsResetStatusEXT", glGetGraphicsResetStatusEXT == NULL);
   glewInfoFunc(fi, "glGetnUniformfvEXT", glGetnUniformfvEXT == NULL);
   glewInfoFunc(fi, "glGetnUniformivEXT", glGetnUniformivEXT == NULL);
   glewInfoFunc(fi, "glReadnPixelsEXT", glReadnPixelsEXT == NULL);
@@ -5804,6 +5890,15 @@ static void _glewInfo_GL_EXT_semaphore_win32 (void)
 
 #endif /* GL_EXT_semaphore_win32 */
 
+#ifdef GL_EXT_separate_depth_stencil
+
+static void _glewInfo_GL_EXT_separate_depth_stencil (void)
+{
+  glewPrintExt("GL_EXT_separate_depth_stencil", GLEW_EXT_separate_depth_stencil, glewIsSupported("GL_EXT_separate_depth_stencil"), glewGetExtension("GL_EXT_separate_depth_stencil"));
+}
+
+#endif /* GL_EXT_separate_depth_stencil */
+
 #ifdef GL_EXT_separate_shader_objects
 
 static void _glewInfo_GL_EXT_separate_shader_objects (void)
@@ -5826,6 +5921,15 @@ static void _glewInfo_GL_EXT_separate_specular_color (void)
 
 #endif /* GL_EXT_separate_specular_color */
 
+#ifdef GL_EXT_shader_clock
+
+static void _glewInfo_GL_EXT_shader_clock (void)
+{
+  glewPrintExt("GL_EXT_shader_clock", GLEW_EXT_shader_clock, glewIsSupported("GL_EXT_shader_clock"), glewGetExtension("GL_EXT_shader_clock"));
+}
+
+#endif /* GL_EXT_shader_clock */
+
 #ifdef GL_EXT_shader_framebuffer_fetch
 
 static void _glewInfo_GL_EXT_shader_framebuffer_fetch (void)
@@ -5934,6 +6038,24 @@ static void _glewInfo_GL_EXT_shader_pixel_local_storage2 (void)
 
 #endif /* GL_EXT_shader_pixel_local_storage2 */
 
+#ifdef GL_EXT_shader_realtime_clock
+
+static void _glewInfo_GL_EXT_shader_realtime_clock (void)
+{
+  glewPrintExt("GL_EXT_shader_realtime_clock", GLEW_EXT_shader_realtime_clock, glewIsSupported("GL_EXT_shader_realtime_clock"), glewGetExtension("GL_EXT_shader_realtime_clock"));
+}
+
+#endif /* GL_EXT_shader_realtime_clock */
+
+#ifdef GL_EXT_shader_samples_identical
+
+static void _glewInfo_GL_EXT_shader_samples_identical (void)
+{
+  glewPrintExt("GL_EXT_shader_samples_identical", GLEW_EXT_shader_samples_identical, glewIsSupported("GL_EXT_shader_samples_identical"), glewGetExtension("GL_EXT_shader_samples_identical"));
+}
+
+#endif /* GL_EXT_shader_samples_identical */
+
 #ifdef GL_EXT_shader_texture_lod
 
 static void _glewInfo_GL_EXT_shader_texture_lod (void)
@@ -5943,6 +6065,15 @@ static void _glewInfo_GL_EXT_shader_texture_lod (void)
 
 #endif /* GL_EXT_shader_texture_lod */
 
+#ifdef GL_EXT_shader_texture_samples
+
+static void _glewInfo_GL_EXT_shader_texture_samples (void)
+{
+  glewPrintExt("GL_EXT_shader_texture_samples", GLEW_EXT_shader_texture_samples, glewIsSupported("GL_EXT_shader_texture_samples"), glewGetExtension("GL_EXT_shader_texture_samples"));
+}
+
+#endif /* GL_EXT_shader_texture_samples */
+
 #ifdef GL_EXT_shadow_funcs
 
 static void _glewInfo_GL_EXT_shadow_funcs (void)
@@ -5977,7 +6108,6 @@ static void _glewInfo_GL_EXT_sparse_texture (void)
   GLboolean fi = glewPrintExt("GL_EXT_sparse_texture", GLEW_EXT_sparse_texture, glewIsSupported("GL_EXT_sparse_texture"), glewGetExtension("GL_EXT_sparse_texture"));
 
   glewInfoFunc(fi, "glTexPageCommitmentEXT", glTexPageCommitmentEXT == NULL);
-  glewInfoFunc(fi, "glTexturePageCommitmentEXT", glTexturePageCommitmentEXT == NULL);
 }
 
 #endif /* GL_EXT_sparse_texture */
@@ -6483,6 +6613,18 @@ static void _glewInfo_GL_EXT_texture_storage (void)
 
 #endif /* GL_EXT_texture_storage */
 
+#ifdef GL_EXT_texture_storage_compression
+
+static void _glewInfo_GL_EXT_texture_storage_compression (void)
+{
+  GLboolean fi = glewPrintExt("GL_EXT_texture_storage_compression", GLEW_EXT_texture_storage_compression, glewIsSupported("GL_EXT_texture_storage_compression"), glewGetExtension("GL_EXT_texture_storage_compression"));
+
+  glewInfoFunc(fi, "glTexStorageAttribs2DEXT", glTexStorageAttribs2DEXT == NULL);
+  glewInfoFunc(fi, "glTexStorageAttribs3DEXT", glTexStorageAttribs3DEXT == NULL);
+}
+
+#endif /* GL_EXT_texture_storage_compression */
+
 #ifdef GL_EXT_texture_swizzle
 
 static void _glewInfo_GL_EXT_texture_swizzle (void)
@@ -6784,6 +6926,24 @@ static void _glewInfo_GL_HP_texture_lighting (void)
 
 #endif /* GL_HP_texture_lighting */
 
+#ifdef GL_HUAWEI_program_binary
+
+static void _glewInfo_GL_HUAWEI_program_binary (void)
+{
+  glewPrintExt("GL_HUAWEI_program_binary", GLEW_HUAWEI_program_binary, glewIsSupported("GL_HUAWEI_program_binary"), glewGetExtension("GL_HUAWEI_program_binary"));
+}
+
+#endif /* GL_HUAWEI_program_binary */
+
+#ifdef GL_HUAWEI_shader_binary
+
+static void _glewInfo_GL_HUAWEI_shader_binary (void)
+{
+  glewPrintExt("GL_HUAWEI_shader_binary", GLEW_HUAWEI_shader_binary, glewIsSupported("GL_HUAWEI_shader_binary"), glewGetExtension("GL_HUAWEI_shader_binary"));
+}
+
+#endif /* GL_HUAWEI_shader_binary */
+
 #ifdef GL_IBM_cull_vertex
 
 static void _glewInfo_GL_IBM_cull_vertex (void)
@@ -6899,6 +7059,15 @@ static void _glewInfo_GL_IMG_program_binary (void)
 
 #endif /* GL_IMG_program_binary */
 
+#ifdef GL_IMG_pvric_end_to_end_signature
+
+static void _glewInfo_GL_IMG_pvric_end_to_end_signature (void)
+{
+  glewPrintExt("GL_IMG_pvric_end_to_end_signature", GLEW_IMG_pvric_end_to_end_signature, glewIsSupported("GL_IMG_pvric_end_to_end_signature"), glewGetExtension("GL_IMG_pvric_end_to_end_signature"));
+}
+
+#endif /* GL_IMG_pvric_end_to_end_signature */
+
 #ifdef GL_IMG_read_format
 
 static void _glewInfo_GL_IMG_read_format (void)
@@ -6953,6 +7122,15 @@ static void _glewInfo_GL_IMG_texture_filter_cubic (void)
 
 #endif /* GL_IMG_texture_filter_cubic */
 
+#ifdef GL_IMG_tile_region_protection
+
+static void _glewInfo_GL_IMG_tile_region_protection (void)
+{
+  glewPrintExt("GL_IMG_tile_region_protection", GLEW_IMG_tile_region_protection, glewIsSupported("GL_IMG_tile_region_protection"), glewGetExtension("GL_IMG_tile_region_protection"));
+}
+
+#endif /* GL_IMG_tile_region_protection */
+
 #ifdef GL_INGR_color_clamp
 
 static void _glewInfo_GL_INGR_color_clamp (void)
@@ -7002,7 +7180,9 @@ static void _glewInfo_GL_INTEL_fragment_shader_ordering (void)
 
 static void _glewInfo_GL_INTEL_framebuffer_CMAA (void)
 {
-  glewPrintExt("GL_INTEL_framebuffer_CMAA", GLEW_INTEL_framebuffer_CMAA, glewIsSupported("GL_INTEL_framebuffer_CMAA"), glewGetExtension("GL_INTEL_framebuffer_CMAA"));
+  GLboolean fi = glewPrintExt("GL_INTEL_framebuffer_CMAA", GLEW_INTEL_framebuffer_CMAA, glewIsSupported("GL_INTEL_framebuffer_CMAA"), glewGetExtension("GL_INTEL_framebuffer_CMAA"));
+
+  glewInfoFunc(fi, "glApplyFramebufferAttachmentCMAAINTEL", glApplyFramebufferAttachmentCMAAINTEL == NULL);
 }
 
 #endif /* GL_INTEL_framebuffer_CMAA */
@@ -7227,6 +7407,24 @@ static void _glewInfo_GL_MESAX_texture_stack (void)
 
 #endif /* GL_MESAX_texture_stack */
 
+#ifdef GL_MESA_bgra
+
+static void _glewInfo_GL_MESA_bgra (void)
+{
+  glewPrintExt("GL_MESA_bgra", GLEW_MESA_bgra, glewIsSupported("GL_MESA_bgra"), glewGetExtension("GL_MESA_bgra"));
+}
+
+#endif /* GL_MESA_bgra */
+
+#ifdef GL_MESA_framebuffer_flip_x
+
+static void _glewInfo_GL_MESA_framebuffer_flip_x (void)
+{
+  glewPrintExt("GL_MESA_framebuffer_flip_x", GLEW_MESA_framebuffer_flip_x, glewIsSupported("GL_MESA_framebuffer_flip_x"), glewGetExtension("GL_MESA_framebuffer_flip_x"));
+}
+
+#endif /* GL_MESA_framebuffer_flip_x */
+
 #ifdef GL_MESA_framebuffer_flip_y
 
 static void _glewInfo_GL_MESA_framebuffer_flip_y (void)
@@ -7239,6 +7437,15 @@ static void _glewInfo_GL_MESA_framebuffer_flip_y (void)
 
 #endif /* GL_MESA_framebuffer_flip_y */
 
+#ifdef GL_MESA_framebuffer_swap_xy
+
+static void _glewInfo_GL_MESA_framebuffer_swap_xy (void)
+{
+  glewPrintExt("GL_MESA_framebuffer_swap_xy", GLEW_MESA_framebuffer_swap_xy, glewIsSupported("GL_MESA_framebuffer_swap_xy"), glewGetExtension("GL_MESA_framebuffer_swap_xy"));
+}
+
+#endif /* GL_MESA_framebuffer_swap_xy */
+
 #ifdef GL_MESA_pack_invert
 
 static void _glewInfo_GL_MESA_pack_invert (void)
@@ -7277,6 +7484,15 @@ static void _glewInfo_GL_MESA_shader_integer_functions (void)
 
 #endif /* GL_MESA_shader_integer_functions */
 
+#ifdef GL_MESA_texture_const_bandwidth
+
+static void _glewInfo_GL_MESA_texture_const_bandwidth (void)
+{
+  glewPrintExt("GL_MESA_texture_const_bandwidth", GLEW_MESA_texture_const_bandwidth, glewIsSupported("GL_MESA_texture_const_bandwidth"), glewGetExtension("GL_MESA_texture_const_bandwidth"));
+}
+
+#endif /* GL_MESA_texture_const_bandwidth */
+
 #ifdef GL_MESA_tile_raster_order
 
 static void _glewInfo_GL_MESA_tile_raster_order (void)
@@ -7395,6 +7611,7 @@ static void _glewInfo_GL_NVX_progress_fence (void)
   GLboolean fi = glewPrintExt("GL_NVX_progress_fence", GLEW_NVX_progress_fence, glewIsSupported("GL_NVX_progress_fence"), glewGetExtension("GL_NVX_progress_fence"));
 
   glewInfoFunc(fi, "glClientWaitSemaphoreui64NVX", glClientWaitSemaphoreui64NVX == NULL);
+  glewInfoFunc(fi, "glCreateProgressFenceNVX", glCreateProgressFenceNVX == NULL);
   glewInfoFunc(fi, "glSignalSemaphoreui64NVX", glSignalSemaphoreui64NVX == NULL);
   glewInfoFunc(fi, "glWaitSemaphoreui64NVX", glWaitSemaphoreui64NVX == NULL);
 }
@@ -8249,6 +8466,20 @@ static void _glewInfo_GL_NV_memory_attachment (void)
 
 #endif /* GL_NV_memory_attachment */
 
+#ifdef GL_NV_memory_object_sparse
+
+static void _glewInfo_GL_NV_memory_object_sparse (void)
+{
+  GLboolean fi = glewPrintExt("GL_NV_memory_object_sparse", GLEW_NV_memory_object_sparse, glewIsSupported("GL_NV_memory_object_sparse"), glewGetExtension("GL_NV_memory_object_sparse"));
+
+  glewInfoFunc(fi, "glBufferPageCommitmentMemNV", glBufferPageCommitmentMemNV == NULL);
+  glewInfoFunc(fi, "glNamedBufferPageCommitmentMemNV", glNamedBufferPageCommitmentMemNV == NULL);
+  glewInfoFunc(fi, "glTexPageCommitmentMemNV", glTexPageCommitmentMemNV == NULL);
+  glewInfoFunc(fi, "glTexturePageCommitmentMemNV", glTexturePageCommitmentMemNV == NULL);
+}
+
+#endif /* GL_NV_memory_object_sparse */
+
 #ifdef GL_NV_mesh_shader
 
 static void _glewInfo_GL_NV_mesh_shader (void)
@@ -8536,6 +8767,15 @@ static void _glewInfo_GL_NV_primitive_restart (void)
 
 #endif /* GL_NV_primitive_restart */
 
+#ifdef GL_NV_primitive_shading_rate
+
+static void _glewInfo_GL_NV_primitive_shading_rate (void)
+{
+  glewPrintExt("GL_NV_primitive_shading_rate", GLEW_NV_primitive_shading_rate, glewIsSupported("GL_NV_primitive_shading_rate"), glewGetExtension("GL_NV_primitive_shading_rate"));
+}
+
+#endif /* GL_NV_primitive_shading_rate */
+
 #ifdef GL_NV_query_resource_tag
 
 static void _glewInfo_GL_NV_query_resource_tag (void)
@@ -8822,6 +9062,7 @@ static void _glewInfo_GL_NV_shading_rate_image (void)
   glewInfoFunc(fi, "glShadingRateImageBarrierNV", glShadingRateImageBarrierNV == NULL);
   glewInfoFunc(fi, "glShadingRateImagePaletteNV", glShadingRateImagePaletteNV == NULL);
   glewInfoFunc(fi, "glShadingRateSampleOrderCustomNV", glShadingRateSampleOrderCustomNV == NULL);
+  glewInfoFunc(fi, "glShadingRateSampleOrderNV", glShadingRateSampleOrderNV == NULL);
 }
 
 #endif /* GL_NV_shading_rate_image */
@@ -9040,6 +9281,19 @@ static void _glewInfo_GL_NV_texture_shader3 (void)
 
 #endif /* GL_NV_texture_shader3 */
 
+#ifdef GL_NV_timeline_semaphore
+
+static void _glewInfo_GL_NV_timeline_semaphore (void)
+{
+  GLboolean fi = glewPrintExt("GL_NV_timeline_semaphore", GLEW_NV_timeline_semaphore, glewIsSupported("GL_NV_timeline_semaphore"), glewGetExtension("GL_NV_timeline_semaphore"));
+
+  glewInfoFunc(fi, "glCreateSemaphoresNV", glCreateSemaphoresNV == NULL);
+  glewInfoFunc(fi, "glGetSemaphoreParameterivNV", glGetSemaphoreParameterivNV == NULL);
+  glewInfoFunc(fi, "glSemaphoreParameterivNV", glSemaphoreParameterivNV == NULL);
+}
+
+#endif /* GL_NV_timeline_semaphore */
+
 #ifdef GL_NV_transform_feedback
 
 static void _glewInfo_GL_NV_transform_feedback (void)
@@ -9078,6 +9332,15 @@ static void _glewInfo_GL_NV_transform_feedback2 (void)
 
 #endif /* GL_NV_transform_feedback2 */
 
+#ifdef GL_NV_uniform_buffer_std430_layout
+
+static void _glewInfo_GL_NV_uniform_buffer_std430_layout (void)
+{
+  glewPrintExt("GL_NV_uniform_buffer_std430_layout", GLEW_NV_uniform_buffer_std430_layout, glewIsSupported("GL_NV_uniform_buffer_std430_layout"), glewGetExtension("GL_NV_uniform_buffer_std430_layout"));
+}
+
+#endif /* GL_NV_uniform_buffer_std430_layout */
+
 #ifdef GL_NV_uniform_buffer_unified_memory
 
 static void _glewInfo_GL_NV_uniform_buffer_unified_memory (void)
@@ -9666,6 +9929,7 @@ static void _glewInfo_GL_OES_matrix_palette (void)
   GLboolean fi = glewPrintExt("GL_OES_matrix_palette", GLEW_OES_matrix_palette, glewIsSupported("GL_OES_matrix_palette"), glewGetExtension("GL_OES_matrix_palette"));
 
   glewInfoFunc(fi, "glCurrentPaletteMatrixOES", glCurrentPaletteMatrixOES == NULL);
+  glewInfoFunc(fi, "glLoadPaletteFromModelViewMatrixOES", glLoadPaletteFromModelViewMatrixOES == NULL);
   glewInfoFunc(fi, "glMatrixIndexPointerOES", glMatrixIndexPointerOES == NULL);
   glewInfoFunc(fi, "glWeightPointerOES", glWeightPointerOES == NULL);
 }
@@ -10177,6 +10441,17 @@ static void _glewInfo_GL_QCOM_extended_get2 (void)
 
 #endif /* GL_QCOM_extended_get2 */
 
+#ifdef GL_QCOM_frame_extrapolation
+
+static void _glewInfo_GL_QCOM_frame_extrapolation (void)
+{
+  GLboolean fi = glewPrintExt("GL_QCOM_frame_extrapolation", GLEW_QCOM_frame_extrapolation, glewIsSupported("GL_QCOM_frame_extrapolation"), glewGetExtension("GL_QCOM_frame_extrapolation"));
+
+  glewInfoFunc(fi, "glExtrapolateTex2DQCOM", glExtrapolateTex2DQCOM == NULL);
+}
+
+#endif /* GL_QCOM_frame_extrapolation */
+
 #ifdef GL_QCOM_framebuffer_foveated
 
 static void _glewInfo_GL_QCOM_framebuffer_foveated (void)
@@ -10189,6 +10464,18 @@ static void _glewInfo_GL_QCOM_framebuffer_foveated (void)
 
 #endif /* GL_QCOM_framebuffer_foveated */
 
+#ifdef GL_QCOM_motion_estimation
+
+static void _glewInfo_GL_QCOM_motion_estimation (void)
+{
+  GLboolean fi = glewPrintExt("GL_QCOM_motion_estimation", GLEW_QCOM_motion_estimation, glewIsSupported("GL_QCOM_motion_estimation"), glewGetExtension("GL_QCOM_motion_estimation"));
+
+  glewInfoFunc(fi, "glTexEstimateMotionQCOM", glTexEstimateMotionQCOM == NULL);
+  glewInfoFunc(fi, "glTexEstimateMotionRegionsQCOM", glTexEstimateMotionRegionsQCOM == NULL);
+}
+
+#endif /* GL_QCOM_motion_estimation */
+
 #ifdef GL_QCOM_perfmon_global_mode
 
 static void _glewInfo_GL_QCOM_perfmon_global_mode (void)
@@ -10198,6 +10485,24 @@ static void _glewInfo_GL_QCOM_perfmon_global_mode (void)
 
 #endif /* GL_QCOM_perfmon_global_mode */
 
+#ifdef GL_QCOM_render_sRGB_R8_RG8
+
+static void _glewInfo_GL_QCOM_render_sRGB_R8_RG8 (void)
+{
+  glewPrintExt("GL_QCOM_render_sRGB_R8_RG8", GLEW_QCOM_render_sRGB_R8_RG8, glewIsSupported("GL_QCOM_render_sRGB_R8_RG8"), glewGetExtension("GL_QCOM_render_sRGB_R8_RG8"));
+}
+
+#endif /* GL_QCOM_render_sRGB_R8_RG8 */
+
+#ifdef GL_QCOM_render_shared_exponent
+
+static void _glewInfo_GL_QCOM_render_shared_exponent (void)
+{
+  glewPrintExt("GL_QCOM_render_shared_exponent", GLEW_QCOM_render_shared_exponent, glewIsSupported("GL_QCOM_render_shared_exponent"), glewGetExtension("GL_QCOM_render_shared_exponent"));
+}
+
+#endif /* GL_QCOM_render_shared_exponent */
+
 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent
 
 static void _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent (void)
@@ -10218,6 +10523,17 @@ static void _glewInfo_GL_QCOM_shader_framebuffer_fetch_rate (void)
 
 #endif /* GL_QCOM_shader_framebuffer_fetch_rate */
 
+#ifdef GL_QCOM_shading_rate
+
+static void _glewInfo_GL_QCOM_shading_rate (void)
+{
+  GLboolean fi = glewPrintExt("GL_QCOM_shading_rate", GLEW_QCOM_shading_rate, glewIsSupported("GL_QCOM_shading_rate"), glewGetExtension("GL_QCOM_shading_rate"));
+
+  glewInfoFunc(fi, "glShadingRateQCOM", glShadingRateQCOM == NULL);
+}
+
+#endif /* GL_QCOM_shading_rate */
+
 #ifdef GL_QCOM_texture_foveated
 
 static void _glewInfo_GL_QCOM_texture_foveated (void)
@@ -10229,6 +10545,15 @@ static void _glewInfo_GL_QCOM_texture_foveated (void)
 
 #endif /* GL_QCOM_texture_foveated */
 
+#ifdef GL_QCOM_texture_foveated2
+
+static void _glewInfo_GL_QCOM_texture_foveated2 (void)
+{
+  glewPrintExt("GL_QCOM_texture_foveated2", GLEW_QCOM_texture_foveated2, glewIsSupported("GL_QCOM_texture_foveated2"), glewGetExtension("GL_QCOM_texture_foveated2"));
+}
+
+#endif /* GL_QCOM_texture_foveated2 */
+
 #ifdef GL_QCOM_texture_foveated_subsampled_layout
 
 static void _glewInfo_GL_QCOM_texture_foveated_subsampled_layout (void)
@@ -10238,6 +10563,15 @@ static void _glewInfo_GL_QCOM_texture_foveated_subsampled_layout (void)
 
 #endif /* GL_QCOM_texture_foveated_subsampled_layout */
 
+#ifdef GL_QCOM_texture_lod_bias
+
+static void _glewInfo_GL_QCOM_texture_lod_bias (void)
+{
+  glewPrintExt("GL_QCOM_texture_lod_bias", GLEW_QCOM_texture_lod_bias, glewIsSupported("GL_QCOM_texture_lod_bias"), glewGetExtension("GL_QCOM_texture_lod_bias"));
+}
+
+#endif /* GL_QCOM_texture_lod_bias */
+
 #ifdef GL_QCOM_tiled_rendering
 
 static void _glewInfo_GL_QCOM_tiled_rendering (void)
@@ -10259,6 +10593,15 @@ static void _glewInfo_GL_QCOM_writeonly_rendering (void)
 
 #endif /* GL_QCOM_writeonly_rendering */
 
+#ifdef GL_QCOM_ycbcr_degamma
+
+static void _glewInfo_GL_QCOM_ycbcr_degamma (void)
+{
+  glewPrintExt("GL_QCOM_ycbcr_degamma", GLEW_QCOM_ycbcr_degamma, glewIsSupported("GL_QCOM_ycbcr_degamma"), glewGetExtension("GL_QCOM_ycbcr_degamma"));
+}
+
+#endif /* GL_QCOM_ycbcr_degamma */
+
 #ifdef GL_REGAL_ES1_0_compatibility
 
 static void _glewInfo_GL_REGAL_ES1_0_compatibility (void)
@@ -11873,6 +12216,15 @@ static void _glewInfo_EGL_ANDROID_recordable (void)
 
 #endif /* EGL_ANDROID_recordable */
 
+#ifdef EGL_ANDROID_telemetry_hint
+
+static void _glewInfo_EGL_ANDROID_telemetry_hint (void)
+{
+  glewPrintExt("EGL_ANDROID_telemetry_hint", EGLEW_ANDROID_telemetry_hint, eglewIsSupported("EGL_ANDROID_telemetry_hint"), eglewGetExtension("EGL_ANDROID_telemetry_hint"));
+}
+
+#endif /* EGL_ANDROID_telemetry_hint */
+
 #ifdef EGL_ANGLE_d3d_share_handle_client_buffer
 
 static void _glewInfo_EGL_ANGLE_d3d_share_handle_client_buffer (void)
@@ -11911,6 +12263,17 @@ static void _glewInfo_EGL_ANGLE_surface_d3d_texture_2d_share_handle (void)
 
 #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */
 
+#ifdef EGL_ANGLE_sync_control_rate
+
+static void _glewInfo_EGL_ANGLE_sync_control_rate (void)
+{
+  GLboolean fi = glewPrintExt("EGL_ANGLE_sync_control_rate", EGLEW_ANGLE_sync_control_rate, eglewIsSupported("EGL_ANGLE_sync_control_rate"), eglewGetExtension("EGL_ANGLE_sync_control_rate"));
+
+  glewInfoFunc(fi, "eglGetMscRateANGLE", eglGetMscRateANGLE == NULL);
+}
+
+#endif /* EGL_ANGLE_sync_control_rate */
+
 #ifdef EGL_ANGLE_window_fixed_size
 
 static void _glewInfo_EGL_ANGLE_window_fixed_size (void)
@@ -12002,6 +12365,15 @@ static void _glewInfo_EGL_EXT_compositor (void)
 
 #endif /* EGL_EXT_compositor */
 
+#ifdef EGL_EXT_config_select_group
+
+static void _glewInfo_EGL_EXT_config_select_group (void)
+{
+  glewPrintExt("EGL_EXT_config_select_group", EGLEW_EXT_config_select_group, eglewIsSupported("EGL_EXT_config_select_group"), eglewGetExtension("EGL_EXT_config_select_group"));
+}
+
+#endif /* EGL_EXT_config_select_group */
+
 #ifdef EGL_EXT_create_context_robustness
 
 static void _glewInfo_EGL_EXT_create_context_robustness (void)
@@ -12029,6 +12401,15 @@ static void _glewInfo_EGL_EXT_device_drm (void)
 
 #endif /* EGL_EXT_device_drm */
 
+#ifdef EGL_EXT_device_drm_render_node
+
+static void _glewInfo_EGL_EXT_device_drm_render_node (void)
+{
+  glewPrintExt("EGL_EXT_device_drm_render_node", EGLEW_EXT_device_drm_render_node, eglewIsSupported("EGL_EXT_device_drm_render_node"), eglewGetExtension("EGL_EXT_device_drm_render_node"));
+}
+
+#endif /* EGL_EXT_device_drm_render_node */
+
 #ifdef EGL_EXT_device_enumeration
 
 static void _glewInfo_EGL_EXT_device_enumeration (void)
@@ -12049,6 +12430,17 @@ static void _glewInfo_EGL_EXT_device_openwf (void)
 
 #endif /* EGL_EXT_device_openwf */
 
+#ifdef EGL_EXT_device_persistent_id
+
+static void _glewInfo_EGL_EXT_device_persistent_id (void)
+{
+  GLboolean fi = glewPrintExt("EGL_EXT_device_persistent_id", EGLEW_EXT_device_persistent_id, eglewIsSupported("EGL_EXT_device_persistent_id"), eglewGetExtension("EGL_EXT_device_persistent_id"));
+
+  glewInfoFunc(fi, "eglQueryDeviceBinaryEXT", eglQueryDeviceBinaryEXT == NULL);
+}
+
+#endif /* EGL_EXT_device_persistent_id */
+
 #ifdef EGL_EXT_device_query
 
 static void _glewInfo_EGL_EXT_device_query (void)
@@ -12062,6 +12454,44 @@ static void _glewInfo_EGL_EXT_device_query (void)
 
 #endif /* EGL_EXT_device_query */
 
+#ifdef EGL_EXT_device_query_name
+
+static void _glewInfo_EGL_EXT_device_query_name (void)
+{
+  glewPrintExt("EGL_EXT_device_query_name", EGLEW_EXT_device_query_name, eglewIsSupported("EGL_EXT_device_query_name"), eglewGetExtension("EGL_EXT_device_query_name"));
+}
+
+#endif /* EGL_EXT_device_query_name */
+
+#ifdef EGL_EXT_display_alloc
+
+static void _glewInfo_EGL_EXT_display_alloc (void)
+{
+  GLboolean fi = glewPrintExt("EGL_EXT_display_alloc", EGLEW_EXT_display_alloc, eglewIsSupported("EGL_EXT_display_alloc"), eglewGetExtension("EGL_EXT_display_alloc"));
+
+  glewInfoFunc(fi, "eglDestroyDisplayEXT", eglDestroyDisplayEXT == NULL);
+}
+
+#endif /* EGL_EXT_display_alloc */
+
+#ifdef EGL_EXT_explicit_device
+
+static void _glewInfo_EGL_EXT_explicit_device (void)
+{
+  glewPrintExt("EGL_EXT_explicit_device", EGLEW_EXT_explicit_device, eglewIsSupported("EGL_EXT_explicit_device"), eglewGetExtension("EGL_EXT_explicit_device"));
+}
+
+#endif /* EGL_EXT_explicit_device */
+
+#ifdef EGL_EXT_gl_colorspace_bt2020_hlg
+
+static void _glewInfo_EGL_EXT_gl_colorspace_bt2020_hlg (void)
+{
+  glewPrintExt("EGL_EXT_gl_colorspace_bt2020_hlg", EGLEW_EXT_gl_colorspace_bt2020_hlg, eglewIsSupported("EGL_EXT_gl_colorspace_bt2020_hlg"), eglewGetExtension("EGL_EXT_gl_colorspace_bt2020_hlg"));
+}
+
+#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */
+
 #ifdef EGL_EXT_gl_colorspace_bt2020_linear
 
 static void _glewInfo_EGL_EXT_gl_colorspace_bt2020_linear (void)
@@ -12258,6 +12688,24 @@ static void _glewInfo_EGL_EXT_platform_x11 (void)
 
 #endif /* EGL_EXT_platform_x11 */
 
+#ifdef EGL_EXT_platform_xcb
+
+static void _glewInfo_EGL_EXT_platform_xcb (void)
+{
+  glewPrintExt("EGL_EXT_platform_xcb", EGLEW_EXT_platform_xcb, eglewIsSupported("EGL_EXT_platform_xcb"), eglewGetExtension("EGL_EXT_platform_xcb"));
+}
+
+#endif /* EGL_EXT_platform_xcb */
+
+#ifdef EGL_EXT_present_opaque
+
+static void _glewInfo_EGL_EXT_present_opaque (void)
+{
+  glewPrintExt("EGL_EXT_present_opaque", EGLEW_EXT_present_opaque, eglewIsSupported("EGL_EXT_present_opaque"), eglewGetExtension("EGL_EXT_present_opaque"));
+}
+
+#endif /* EGL_EXT_present_opaque */
+
 #ifdef EGL_EXT_protected_content
 
 static void _glewInfo_EGL_EXT_protected_content (void)
@@ -12276,6 +12724,15 @@ static void _glewInfo_EGL_EXT_protected_surface (void)
 
 #endif /* EGL_EXT_protected_surface */
 
+#ifdef EGL_EXT_query_reset_notification_strategy
+
+static void _glewInfo_EGL_EXT_query_reset_notification_strategy (void)
+{
+  glewPrintExt("EGL_EXT_query_reset_notification_strategy", EGLEW_EXT_query_reset_notification_strategy, eglewIsSupported("EGL_EXT_query_reset_notification_strategy"), eglewGetExtension("EGL_EXT_query_reset_notification_strategy"));
+}
+
+#endif /* EGL_EXT_query_reset_notification_strategy */
+
 #ifdef EGL_EXT_stream_consumer_egloutput
 
 static void _glewInfo_EGL_EXT_stream_consumer_egloutput (void)
@@ -12305,6 +12762,17 @@ static void _glewInfo_EGL_EXT_surface_SMPTE2086_metadata (void)
 
 #endif /* EGL_EXT_surface_SMPTE2086_metadata */
 
+#ifdef EGL_EXT_surface_compression
+
+static void _glewInfo_EGL_EXT_surface_compression (void)
+{
+  GLboolean fi = glewPrintExt("EGL_EXT_surface_compression", EGLEW_EXT_surface_compression, eglewIsSupported("EGL_EXT_surface_compression"), eglewGetExtension("EGL_EXT_surface_compression"));
+
+  glewInfoFunc(fi, "eglQuerySupportedCompressionRatesEXT", eglQuerySupportedCompressionRatesEXT == NULL);
+}
+
+#endif /* EGL_EXT_surface_compression */
+
 #ifdef EGL_EXT_swap_buffers_with_damage
 
 static void _glewInfo_EGL_EXT_swap_buffers_with_damage (void)
@@ -12993,6 +13461,29 @@ static void _glewInfo_EGL_NV_robustness_video_memory_purge (void)
 
 #endif /* EGL_NV_robustness_video_memory_purge */
 
+#ifdef EGL_NV_stream_consumer_eglimage
+
+static void _glewInfo_EGL_NV_stream_consumer_eglimage (void)
+{
+  GLboolean fi = glewPrintExt("EGL_NV_stream_consumer_eglimage", EGLEW_NV_stream_consumer_eglimage, eglewIsSupported("EGL_NV_stream_consumer_eglimage"), eglewGetExtension("EGL_NV_stream_consumer_eglimage"));
+
+  glewInfoFunc(fi, "eglQueryStreamConsumerEventNV", eglQueryStreamConsumerEventNV == NULL);
+  glewInfoFunc(fi, "eglStreamAcquireImageNV", eglStreamAcquireImageNV == NULL);
+  glewInfoFunc(fi, "eglStreamImageConsumerConnectNV", eglStreamImageConsumerConnectNV == NULL);
+  glewInfoFunc(fi, "eglStreamReleaseImageNV", eglStreamReleaseImageNV == NULL);
+}
+
+#endif /* EGL_NV_stream_consumer_eglimage */
+
+#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib
+
+static void _glewInfo_EGL_NV_stream_consumer_eglimage_use_scanout_attrib (void)
+{
+  glewPrintExt("EGL_NV_stream_consumer_eglimage_use_scanout_attrib", EGLEW_NV_stream_consumer_eglimage_use_scanout_attrib, eglewIsSupported("EGL_NV_stream_consumer_eglimage_use_scanout_attrib"), eglewGetExtension("EGL_NV_stream_consumer_eglimage_use_scanout_attrib"));
+}
+
+#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */
+
 #ifdef EGL_NV_stream_consumer_gltexture_yuv
 
 static void _glewInfo_EGL_NV_stream_consumer_gltexture_yuv (void)
@@ -13213,6 +13704,24 @@ static void _glewInfo_EGL_NV_triple_buffer (void)
 
 #endif /* EGL_NV_triple_buffer */
 
+#ifdef EGL_QNX_image_native_buffer
+
+static void _glewInfo_EGL_QNX_image_native_buffer (void)
+{
+  glewPrintExt("EGL_QNX_image_native_buffer", EGLEW_QNX_image_native_buffer, eglewIsSupported("EGL_QNX_image_native_buffer"), eglewGetExtension("EGL_QNX_image_native_buffer"));
+}
+
+#endif /* EGL_QNX_image_native_buffer */
+
+#ifdef EGL_QNX_platform_screen
+
+static void _glewInfo_EGL_QNX_platform_screen (void)
+{
+  glewPrintExt("EGL_QNX_platform_screen", EGLEW_QNX_platform_screen, eglewIsSupported("EGL_QNX_platform_screen"), eglewGetExtension("EGL_QNX_platform_screen"));
+}
+
+#endif /* EGL_QNX_platform_screen */
+
 #ifdef EGL_TIZEN_image_native_buffer
 
 static void _glewInfo_EGL_TIZEN_image_native_buffer (void)
@@ -14183,6 +14692,15 @@ static void _glewInfo_GLX_EXT_framebuffer_sRGB (void)
 
 #endif /* GLX_EXT_framebuffer_sRGB */
 
+#ifdef GLX_EXT_get_drawable_type
+
+static void _glewInfo_GLX_EXT_get_drawable_type (void)
+{
+  glewPrintExt("GLX_EXT_get_drawable_type", GLXEW_EXT_get_drawable_type, glxewIsSupported("GLX_EXT_get_drawable_type"), glxewGetExtension("GLX_EXT_get_drawable_type"));
+}
+
+#endif /* GLX_EXT_get_drawable_type */
+
 #ifdef GLX_EXT_import_context
 
 static void _glewInfo_GLX_EXT_import_context (void)
@@ -15574,6 +16092,9 @@ static void glewInfo (void)
 #ifdef GL_ARM_rgba8
   _glewInfo_GL_ARM_rgba8();
 #endif /* GL_ARM_rgba8 */
+#ifdef GL_ARM_shader_core_properties
+  _glewInfo_GL_ARM_shader_core_properties();
+#endif /* GL_ARM_shader_core_properties */
 #ifdef GL_ARM_shader_framebuffer_fetch
   _glewInfo_GL_ARM_shader_framebuffer_fetch();
 #endif /* GL_ARM_shader_framebuffer_fetch */
@@ -15667,6 +16188,9 @@ static void glewInfo (void)
 #ifdef GL_EXT_EGL_image_storage
   _glewInfo_GL_EXT_EGL_image_storage();
 #endif /* GL_EXT_EGL_image_storage */
+#ifdef GL_EXT_EGL_image_storage_compression
+  _glewInfo_GL_EXT_EGL_image_storage_compression();
+#endif /* GL_EXT_EGL_image_storage_compression */
 #ifdef GL_EXT_EGL_sync
   _glewInfo_GL_EXT_EGL_sync();
 #endif /* GL_EXT_EGL_sync */
@@ -15814,9 +16338,21 @@ static void glewInfo (void)
 #ifdef GL_EXT_fragment_lighting
   _glewInfo_GL_EXT_fragment_lighting();
 #endif /* GL_EXT_fragment_lighting */
+#ifdef GL_EXT_fragment_shading_rate
+  _glewInfo_GL_EXT_fragment_shading_rate();
+#endif /* GL_EXT_fragment_shading_rate */
+#ifdef GL_EXT_fragment_shading_rate_attachment
+  _glewInfo_GL_EXT_fragment_shading_rate_attachment();
+#endif /* GL_EXT_fragment_shading_rate_attachment */
+#ifdef GL_EXT_fragment_shading_rate_primitive
+  _glewInfo_GL_EXT_fragment_shading_rate_primitive();
+#endif /* GL_EXT_fragment_shading_rate_primitive */
 #ifdef GL_EXT_framebuffer_blit
   _glewInfo_GL_EXT_framebuffer_blit();
 #endif /* GL_EXT_framebuffer_blit */
+#ifdef GL_EXT_framebuffer_blit_layers
+  _glewInfo_GL_EXT_framebuffer_blit_layers();
+#endif /* GL_EXT_framebuffer_blit_layers */
 #ifdef GL_EXT_framebuffer_multisample
   _glewInfo_GL_EXT_framebuffer_multisample();
 #endif /* GL_EXT_framebuffer_multisample */
@@ -15880,6 +16416,9 @@ static void glewInfo (void)
 #ifdef GL_EXT_memory_object_win32
   _glewInfo_GL_EXT_memory_object_win32();
 #endif /* GL_EXT_memory_object_win32 */
+#ifdef GL_EXT_mesh_shader
+  _glewInfo_GL_EXT_mesh_shader();
+#endif /* GL_EXT_mesh_shader */
 #ifdef GL_EXT_misc_attribute
   _glewInfo_GL_EXT_misc_attribute();
 #endif /* GL_EXT_misc_attribute */
@@ -16000,12 +16539,18 @@ static void glewInfo (void)
 #ifdef GL_EXT_semaphore_win32
   _glewInfo_GL_EXT_semaphore_win32();
 #endif /* GL_EXT_semaphore_win32 */
+#ifdef GL_EXT_separate_depth_stencil
+  _glewInfo_GL_EXT_separate_depth_stencil();
+#endif /* GL_EXT_separate_depth_stencil */
 #ifdef GL_EXT_separate_shader_objects
   _glewInfo_GL_EXT_separate_shader_objects();
 #endif /* GL_EXT_separate_shader_objects */
 #ifdef GL_EXT_separate_specular_color
   _glewInfo_GL_EXT_separate_specular_color();
 #endif /* GL_EXT_separate_specular_color */
+#ifdef GL_EXT_shader_clock
+  _glewInfo_GL_EXT_shader_clock();
+#endif /* GL_EXT_shader_clock */
 #ifdef GL_EXT_shader_framebuffer_fetch
   _glewInfo_GL_EXT_shader_framebuffer_fetch();
 #endif /* GL_EXT_shader_framebuffer_fetch */
@@ -16039,9 +16584,18 @@ static void glewInfo (void)
 #ifdef GL_EXT_shader_pixel_local_storage2
   _glewInfo_GL_EXT_shader_pixel_local_storage2();
 #endif /* GL_EXT_shader_pixel_local_storage2 */
+#ifdef GL_EXT_shader_realtime_clock
+  _glewInfo_GL_EXT_shader_realtime_clock();
+#endif /* GL_EXT_shader_realtime_clock */
+#ifdef GL_EXT_shader_samples_identical
+  _glewInfo_GL_EXT_shader_samples_identical();
+#endif /* GL_EXT_shader_samples_identical */
 #ifdef GL_EXT_shader_texture_lod
   _glewInfo_GL_EXT_shader_texture_lod();
 #endif /* GL_EXT_shader_texture_lod */
+#ifdef GL_EXT_shader_texture_samples
+  _glewInfo_GL_EXT_shader_texture_samples();
+#endif /* GL_EXT_shader_texture_samples */
 #ifdef GL_EXT_shadow_funcs
   _glewInfo_GL_EXT_shadow_funcs();
 #endif /* GL_EXT_shadow_funcs */
@@ -16207,6 +16761,9 @@ static void glewInfo (void)
 #ifdef GL_EXT_texture_storage
   _glewInfo_GL_EXT_texture_storage();
 #endif /* GL_EXT_texture_storage */
+#ifdef GL_EXT_texture_storage_compression
+  _glewInfo_GL_EXT_texture_storage_compression();
+#endif /* GL_EXT_texture_storage_compression */
 #ifdef GL_EXT_texture_swizzle
   _glewInfo_GL_EXT_texture_swizzle();
 #endif /* GL_EXT_texture_swizzle */
@@ -16273,6 +16830,12 @@ static void glewInfo (void)
 #ifdef GL_HP_texture_lighting
   _glewInfo_GL_HP_texture_lighting();
 #endif /* GL_HP_texture_lighting */
+#ifdef GL_HUAWEI_program_binary
+  _glewInfo_GL_HUAWEI_program_binary();
+#endif /* GL_HUAWEI_program_binary */
+#ifdef GL_HUAWEI_shader_binary
+  _glewInfo_GL_HUAWEI_shader_binary();
+#endif /* GL_HUAWEI_shader_binary */
 #ifdef GL_IBM_cull_vertex
   _glewInfo_GL_IBM_cull_vertex();
 #endif /* GL_IBM_cull_vertex */
@@ -16303,6 +16866,9 @@ static void glewInfo (void)
 #ifdef GL_IMG_program_binary
   _glewInfo_GL_IMG_program_binary();
 #endif /* GL_IMG_program_binary */
+#ifdef GL_IMG_pvric_end_to_end_signature
+  _glewInfo_GL_IMG_pvric_end_to_end_signature();
+#endif /* GL_IMG_pvric_end_to_end_signature */
 #ifdef GL_IMG_read_format
   _glewInfo_GL_IMG_read_format();
 #endif /* GL_IMG_read_format */
@@ -16321,6 +16887,9 @@ static void glewInfo (void)
 #ifdef GL_IMG_texture_filter_cubic
   _glewInfo_GL_IMG_texture_filter_cubic();
 #endif /* GL_IMG_texture_filter_cubic */
+#ifdef GL_IMG_tile_region_protection
+  _glewInfo_GL_IMG_tile_region_protection();
+#endif /* GL_IMG_tile_region_protection */
 #ifdef GL_INGR_color_clamp
   _glewInfo_GL_INGR_color_clamp();
 #endif /* GL_INGR_color_clamp */
@@ -16396,9 +16965,18 @@ static void glewInfo (void)
 #ifdef GL_MESAX_texture_stack
   _glewInfo_GL_MESAX_texture_stack();
 #endif /* GL_MESAX_texture_stack */
+#ifdef GL_MESA_bgra
+  _glewInfo_GL_MESA_bgra();
+#endif /* GL_MESA_bgra */
+#ifdef GL_MESA_framebuffer_flip_x
+  _glewInfo_GL_MESA_framebuffer_flip_x();
+#endif /* GL_MESA_framebuffer_flip_x */
 #ifdef GL_MESA_framebuffer_flip_y
   _glewInfo_GL_MESA_framebuffer_flip_y();
 #endif /* GL_MESA_framebuffer_flip_y */
+#ifdef GL_MESA_framebuffer_swap_xy
+  _glewInfo_GL_MESA_framebuffer_swap_xy();
+#endif /* GL_MESA_framebuffer_swap_xy */
 #ifdef GL_MESA_pack_invert
   _glewInfo_GL_MESA_pack_invert();
 #endif /* GL_MESA_pack_invert */
@@ -16411,6 +16989,9 @@ static void glewInfo (void)
 #ifdef GL_MESA_shader_integer_functions
   _glewInfo_GL_MESA_shader_integer_functions();
 #endif /* GL_MESA_shader_integer_functions */
+#ifdef GL_MESA_texture_const_bandwidth
+  _glewInfo_GL_MESA_texture_const_bandwidth();
+#endif /* GL_MESA_texture_const_bandwidth */
 #ifdef GL_MESA_tile_raster_order
   _glewInfo_GL_MESA_tile_raster_order();
 #endif /* GL_MESA_tile_raster_order */
@@ -16642,6 +17223,9 @@ static void glewInfo (void)
 #ifdef GL_NV_memory_attachment
   _glewInfo_GL_NV_memory_attachment();
 #endif /* GL_NV_memory_attachment */
+#ifdef GL_NV_memory_object_sparse
+  _glewInfo_GL_NV_memory_object_sparse();
+#endif /* GL_NV_memory_object_sparse */
 #ifdef GL_NV_mesh_shader
   _glewInfo_GL_NV_mesh_shader();
 #endif /* GL_NV_mesh_shader */
@@ -16702,6 +17286,9 @@ static void glewInfo (void)
 #ifdef GL_NV_primitive_restart
   _glewInfo_GL_NV_primitive_restart();
 #endif /* GL_NV_primitive_restart */
+#ifdef GL_NV_primitive_shading_rate
+  _glewInfo_GL_NV_primitive_shading_rate();
+#endif /* GL_NV_primitive_shading_rate */
 #ifdef GL_NV_query_resource_tag
   _glewInfo_GL_NV_query_resource_tag();
 #endif /* GL_NV_query_resource_tag */
@@ -16849,12 +17436,18 @@ static void glewInfo (void)
 #ifdef GL_NV_texture_shader3
   _glewInfo_GL_NV_texture_shader3();
 #endif /* GL_NV_texture_shader3 */
+#ifdef GL_NV_timeline_semaphore
+  _glewInfo_GL_NV_timeline_semaphore();
+#endif /* GL_NV_timeline_semaphore */
 #ifdef GL_NV_transform_feedback
   _glewInfo_GL_NV_transform_feedback();
 #endif /* GL_NV_transform_feedback */
 #ifdef GL_NV_transform_feedback2
   _glewInfo_GL_NV_transform_feedback2();
 #endif /* GL_NV_transform_feedback2 */
+#ifdef GL_NV_uniform_buffer_std430_layout
+  _glewInfo_GL_NV_uniform_buffer_std430_layout();
+#endif /* GL_NV_uniform_buffer_std430_layout */
 #ifdef GL_NV_uniform_buffer_unified_memory
   _glewInfo_GL_NV_uniform_buffer_unified_memory();
 #endif /* GL_NV_uniform_buffer_unified_memory */
@@ -17134,30 +17727,54 @@ static void glewInfo (void)
 #ifdef GL_QCOM_extended_get2
   _glewInfo_GL_QCOM_extended_get2();
 #endif /* GL_QCOM_extended_get2 */
+#ifdef GL_QCOM_frame_extrapolation
+  _glewInfo_GL_QCOM_frame_extrapolation();
+#endif /* GL_QCOM_frame_extrapolation */
 #ifdef GL_QCOM_framebuffer_foveated
   _glewInfo_GL_QCOM_framebuffer_foveated();
 #endif /* GL_QCOM_framebuffer_foveated */
+#ifdef GL_QCOM_motion_estimation
+  _glewInfo_GL_QCOM_motion_estimation();
+#endif /* GL_QCOM_motion_estimation */
 #ifdef GL_QCOM_perfmon_global_mode
   _glewInfo_GL_QCOM_perfmon_global_mode();
 #endif /* GL_QCOM_perfmon_global_mode */
+#ifdef GL_QCOM_render_sRGB_R8_RG8
+  _glewInfo_GL_QCOM_render_sRGB_R8_RG8();
+#endif /* GL_QCOM_render_sRGB_R8_RG8 */
+#ifdef GL_QCOM_render_shared_exponent
+  _glewInfo_GL_QCOM_render_shared_exponent();
+#endif /* GL_QCOM_render_shared_exponent */
 #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent
   _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent();
 #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */
 #ifdef GL_QCOM_shader_framebuffer_fetch_rate
   _glewInfo_GL_QCOM_shader_framebuffer_fetch_rate();
 #endif /* GL_QCOM_shader_framebuffer_fetch_rate */
+#ifdef GL_QCOM_shading_rate
+  _glewInfo_GL_QCOM_shading_rate();
+#endif /* GL_QCOM_shading_rate */
 #ifdef GL_QCOM_texture_foveated
   _glewInfo_GL_QCOM_texture_foveated();
 #endif /* GL_QCOM_texture_foveated */
+#ifdef GL_QCOM_texture_foveated2
+  _glewInfo_GL_QCOM_texture_foveated2();
+#endif /* GL_QCOM_texture_foveated2 */
 #ifdef GL_QCOM_texture_foveated_subsampled_layout
   _glewInfo_GL_QCOM_texture_foveated_subsampled_layout();
 #endif /* GL_QCOM_texture_foveated_subsampled_layout */
+#ifdef GL_QCOM_texture_lod_bias
+  _glewInfo_GL_QCOM_texture_lod_bias();
+#endif /* GL_QCOM_texture_lod_bias */
 #ifdef GL_QCOM_tiled_rendering
   _glewInfo_GL_QCOM_tiled_rendering();
 #endif /* GL_QCOM_tiled_rendering */
 #ifdef GL_QCOM_writeonly_rendering
   _glewInfo_GL_QCOM_writeonly_rendering();
 #endif /* GL_QCOM_writeonly_rendering */
+#ifdef GL_QCOM_ycbcr_degamma
+  _glewInfo_GL_QCOM_ycbcr_degamma();
+#endif /* GL_QCOM_ycbcr_degamma */
 #ifdef GL_REGAL_ES1_0_compatibility
   _glewInfo_GL_REGAL_ES1_0_compatibility();
 #endif /* GL_REGAL_ES1_0_compatibility */
@@ -17725,7 +18342,7 @@ static void wglewInfo ()
 
 #elif !defined(GLEW_EGL) && !defined(GLEW_OSMESA) /* _UNIX */
 
-static void glxewInfo ()
+static void glxewInfo (void)
 {
 #ifdef GLX_VERSION_1_2
   _glewInfo_GLX_VERSION_1_2();
@@ -17802,6 +18419,9 @@ static void glxewInfo ()
 #ifdef GLX_EXT_framebuffer_sRGB
   _glewInfo_GLX_EXT_framebuffer_sRGB();
 #endif /* GLX_EXT_framebuffer_sRGB */
+#ifdef GLX_EXT_get_drawable_type
+  _glewInfo_GLX_EXT_get_drawable_type();
+#endif /* GLX_EXT_get_drawable_type */
 #ifdef GLX_EXT_import_context
   _glewInfo_GLX_EXT_import_context();
 #endif /* GLX_EXT_import_context */
@@ -17953,7 +18573,7 @@ static void glxewInfo ()
 
 #elif defined(GLEW_EGL)
 
-static void eglewInfo ()
+static void eglewInfo (void)
 {
 #ifdef EGL_VERSION_1_0
   _glewInfo_EGL_VERSION_1_0();
@@ -18006,6 +18626,9 @@ static void eglewInfo ()
 #ifdef EGL_ANDROID_recordable
   _glewInfo_EGL_ANDROID_recordable();
 #endif /* EGL_ANDROID_recordable */
+#ifdef EGL_ANDROID_telemetry_hint
+  _glewInfo_EGL_ANDROID_telemetry_hint();
+#endif /* EGL_ANDROID_telemetry_hint */
 #ifdef EGL_ANGLE_d3d_share_handle_client_buffer
   _glewInfo_EGL_ANGLE_d3d_share_handle_client_buffer();
 #endif /* EGL_ANGLE_d3d_share_handle_client_buffer */
@@ -18018,6 +18641,9 @@ static void eglewInfo ()
 #ifdef EGL_ANGLE_surface_d3d_texture_2d_share_handle
   _glewInfo_EGL_ANGLE_surface_d3d_texture_2d_share_handle();
 #endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */
+#ifdef EGL_ANGLE_sync_control_rate
+  _glewInfo_EGL_ANGLE_sync_control_rate();
+#endif /* EGL_ANGLE_sync_control_rate */
 #ifdef EGL_ANGLE_window_fixed_size
   _glewInfo_EGL_ANGLE_window_fixed_size();
 #endif /* EGL_ANGLE_window_fixed_size */
@@ -18045,6 +18671,9 @@ static void eglewInfo ()
 #ifdef EGL_EXT_compositor
   _glewInfo_EGL_EXT_compositor();
 #endif /* EGL_EXT_compositor */
+#ifdef EGL_EXT_config_select_group
+  _glewInfo_EGL_EXT_config_select_group();
+#endif /* EGL_EXT_config_select_group */
 #ifdef EGL_EXT_create_context_robustness
   _glewInfo_EGL_EXT_create_context_robustness();
 #endif /* EGL_EXT_create_context_robustness */
@@ -18054,15 +18683,33 @@ static void eglewInfo ()
 #ifdef EGL_EXT_device_drm
   _glewInfo_EGL_EXT_device_drm();
 #endif /* EGL_EXT_device_drm */
+#ifdef EGL_EXT_device_drm_render_node
+  _glewInfo_EGL_EXT_device_drm_render_node();
+#endif /* EGL_EXT_device_drm_render_node */
 #ifdef EGL_EXT_device_enumeration
   _glewInfo_EGL_EXT_device_enumeration();
 #endif /* EGL_EXT_device_enumeration */
 #ifdef EGL_EXT_device_openwf
   _glewInfo_EGL_EXT_device_openwf();
 #endif /* EGL_EXT_device_openwf */
+#ifdef EGL_EXT_device_persistent_id
+  _glewInfo_EGL_EXT_device_persistent_id();
+#endif /* EGL_EXT_device_persistent_id */
 #ifdef EGL_EXT_device_query
   _glewInfo_EGL_EXT_device_query();
 #endif /* EGL_EXT_device_query */
+#ifdef EGL_EXT_device_query_name
+  _glewInfo_EGL_EXT_device_query_name();
+#endif /* EGL_EXT_device_query_name */
+#ifdef EGL_EXT_display_alloc
+  _glewInfo_EGL_EXT_display_alloc();
+#endif /* EGL_EXT_display_alloc */
+#ifdef EGL_EXT_explicit_device
+  _glewInfo_EGL_EXT_explicit_device();
+#endif /* EGL_EXT_explicit_device */
+#ifdef EGL_EXT_gl_colorspace_bt2020_hlg
+  _glewInfo_EGL_EXT_gl_colorspace_bt2020_hlg();
+#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */
 #ifdef EGL_EXT_gl_colorspace_bt2020_linear
   _glewInfo_EGL_EXT_gl_colorspace_bt2020_linear();
 #endif /* EGL_EXT_gl_colorspace_bt2020_linear */
@@ -18123,12 +18770,21 @@ static void eglewInfo ()
 #ifdef EGL_EXT_platform_x11
   _glewInfo_EGL_EXT_platform_x11();
 #endif /* EGL_EXT_platform_x11 */
+#ifdef EGL_EXT_platform_xcb
+  _glewInfo_EGL_EXT_platform_xcb();
+#endif /* EGL_EXT_platform_xcb */
+#ifdef EGL_EXT_present_opaque
+  _glewInfo_EGL_EXT_present_opaque();
+#endif /* EGL_EXT_present_opaque */
 #ifdef EGL_EXT_protected_content
   _glewInfo_EGL_EXT_protected_content();
 #endif /* EGL_EXT_protected_content */
 #ifdef EGL_EXT_protected_surface
   _glewInfo_EGL_EXT_protected_surface();
 #endif /* EGL_EXT_protected_surface */
+#ifdef EGL_EXT_query_reset_notification_strategy
+  _glewInfo_EGL_EXT_query_reset_notification_strategy();
+#endif /* EGL_EXT_query_reset_notification_strategy */
 #ifdef EGL_EXT_stream_consumer_egloutput
   _glewInfo_EGL_EXT_stream_consumer_egloutput();
 #endif /* EGL_EXT_stream_consumer_egloutput */
@@ -18138,6 +18794,9 @@ static void eglewInfo ()
 #ifdef EGL_EXT_surface_SMPTE2086_metadata
   _glewInfo_EGL_EXT_surface_SMPTE2086_metadata();
 #endif /* EGL_EXT_surface_SMPTE2086_metadata */
+#ifdef EGL_EXT_surface_compression
+  _glewInfo_EGL_EXT_surface_compression();
+#endif /* EGL_EXT_surface_compression */
 #ifdef EGL_EXT_swap_buffers_with_damage
   _glewInfo_EGL_EXT_swap_buffers_with_damage();
 #endif /* EGL_EXT_swap_buffers_with_damage */
@@ -18342,6 +19001,12 @@ static void eglewInfo ()
 #ifdef EGL_NV_robustness_video_memory_purge
   _glewInfo_EGL_NV_robustness_video_memory_purge();
 #endif /* EGL_NV_robustness_video_memory_purge */
+#ifdef EGL_NV_stream_consumer_eglimage
+  _glewInfo_EGL_NV_stream_consumer_eglimage();
+#endif /* EGL_NV_stream_consumer_eglimage */
+#ifdef EGL_NV_stream_consumer_eglimage_use_scanout_attrib
+  _glewInfo_EGL_NV_stream_consumer_eglimage_use_scanout_attrib();
+#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */
 #ifdef EGL_NV_stream_consumer_gltexture_yuv
   _glewInfo_EGL_NV_stream_consumer_gltexture_yuv();
 #endif /* EGL_NV_stream_consumer_gltexture_yuv */
@@ -18408,6 +19073,12 @@ static void eglewInfo ()
 #ifdef EGL_NV_triple_buffer
   _glewInfo_EGL_NV_triple_buffer();
 #endif /* EGL_NV_triple_buffer */
+#ifdef EGL_QNX_image_native_buffer
+  _glewInfo_EGL_QNX_image_native_buffer();
+#endif /* EGL_QNX_image_native_buffer */
+#ifdef EGL_QNX_platform_screen
+  _glewInfo_EGL_QNX_platform_screen();
+#endif /* EGL_QNX_platform_screen */
 #ifdef EGL_TIZEN_image_native_buffer
   _glewInfo_EGL_TIZEN_image_native_buffer();
 #endif /* EGL_TIZEN_image_native_buffer */
@@ -18617,7 +19288,6 @@ GLboolean glewCreateContext (struct createParams *params)
   EGLDeviceEXT devices[1];
   EGLint numDevices;
   EGLSurface  surface;
-  EGLint majorVersion, minorVersion;
   EGLint configAttribs[] = {
         EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
         EGL_RED_SIZE, 1,
@@ -18651,6 +19321,8 @@ GLboolean glewCreateContext (struct createParams *params)
   PFNEGLMAKECURRENTPROC           makeCurrent = NULL;
   PFNEGLCREATEPBUFFERSURFACEPROC  createPbufferSurface = NULL;
 
+  (void) params; /* not used */
+
   /* Load necessary entry points */
   queryDevices         = (PFNEGLQUERYDEVICESEXTPROC)       eglGetProcAddress("eglQueryDevicesEXT");
   getPlatformDisplay   = (PFNEGLGETPLATFORMDISPLAYEXTPROC) eglGetProcAddress("eglGetPlatformDisplayEXT");
@@ -18721,7 +19393,7 @@ GLboolean glewCreateContext (struct createParams *params)
   return GL_FALSE;
 }
 
-void glewDestroyContext ()
+void glewDestroyContext (void)
 {
   if (NULL != ctx) eglDestroyContext(display, ctx);
 }
@@ -18736,20 +19408,22 @@ static GLubyte *osmPixels = NULL;
 
 GLboolean glewCreateContext (struct createParams *params)
 {
+  (void) params; /* not used */
+
   ctx = OSMesaCreateContext(OSMESA_RGBA, NULL);
   if (NULL == ctx) return GL_TRUE;
   if (NULL == osmPixels)
   {
     osmPixels = (GLubyte *) calloc(osmWidth*osmHeight*4, 1);
   }
-  if (!OSMesaMakeCurrent(ctx, osmPixels, GL_UNSIGNED_BYTE, osmWidth, osmHeight))
+  if (!OSMesaMakeCurrent(ctx, osmPixels, osmFormat, osmWidth, osmHeight))
   {
       return GL_TRUE;
   }
   return GL_FALSE;
 }
 
-void glewDestroyContext ()
+void glewDestroyContext (void)
 {
   if (NULL != ctx) OSMesaDestroyContext(ctx);
 }
@@ -18834,7 +19508,7 @@ GLboolean glewCreateContext (struct createParams* params)
   return GL_FALSE;
 }
 
-void glewDestroyContext ()
+void glewDestroyContext (void)
 {
   if (NULL != rc) wglMakeCurrent(NULL, NULL);
   if (NULL != rc) wglDeleteContext(rc);
@@ -18892,7 +19566,7 @@ GLboolean glewCreateContext (struct createParams *params)
   return GL_FALSE;
 }
 
-void glewDestroyContext ()
+void glewDestroyContext (void)
 {
   CGLSetCurrentContext(octx);
   CGLReleaseContext(ctx);
@@ -18905,10 +19579,11 @@ void glewDestroyContext ()
 GLboolean glewCreateContext (struct createParams *params)
 {
   /* TODO: Haiku: We need to call C++ code here */
+  (void) params; /* not used */
   return GL_FALSE;
 }
 
-void glewDestroyContext ()
+void glewDestroyContext (void)
 {
   /* TODO: Haiku: We need to call C++ code here */
 }
@@ -19016,7 +19691,7 @@ GLboolean glewCreateContext (struct createParams *params)
   return GL_FALSE;
 }
 
-void glewDestroyContext ()
+void glewDestroyContext (void)
 {
   if (NULL != dpy && NULL != ctx) glXDestroyContext(dpy, ctx);
   if (NULL != dpy && 0 != wnd) XDestroyWindow(dpy, wnd);
diff --git a/3rdparty/glew/src/visualinfo.c b/3rdparty/glew/src/visualinfo.c
index 6879f78d00f..dad8a9e94fc 100644
--- a/3rdparty/glew/src/visualinfo.c
+++ b/3rdparty/glew/src/visualinfo.c
@@ -4,7 +4,7 @@
 ** Copyright (C) Nate Robins, 1997
 **               Michael Wimmer, 1999
 **               Milan Ikits, 2002-2008
-**               Nigel Stewart, 2008-2019
+**               Nigel Stewart, 2008-2025
 **
 ** visualinfo is a small utility that displays all available visuals,
 ** aka. pixelformats, in an OpenGL system along with renderer version
@@ -36,6 +36,9 @@
 #include <GL/glew.h>
 #if defined(GLEW_OSMESA)
 #define GLAPI extern
+#ifndef APIENTRY
+#define APIENTRY
+#endif
 #include <GL/osmesa.h>
 #elif defined(GLEW_EGL)
 #include <GL/eglew.h>
@@ -48,18 +51,6 @@
 #include <GL/glxew.h>
 #endif
 
-#ifdef GLEW_MX
-GLEWContext _glewctx;
-#  define glewGetContext() (&_glewctx)
-#  ifdef _WIN32
-WGLEWContext _wglewctx;
-#    define wglewGetContext() (&_wglewctx)
-#  elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX)
-GLXEWContext _glxewctx;
-#    define glxewGetContext() (&_glxewctx)
-#  endif
-#endif /* GLEW_MX */
-
 typedef struct GLContextStruct
 {
 #if defined(GLEW_OSMESA)
@@ -123,6 +114,13 @@ main (int argc, char** argv)
     return 1;
   }
 
+#if defined(GLEW_EGL)
+  {
+    fprintf(stderr, "Error [main]: EGL not supported by visualinfo.\n");
+    return 1;
+  }
+#endif
+
   /* ---------------------------------------------------------------------- */
   /* create OpenGL rendering context */
   InitContext(&ctx);
@@ -136,16 +134,7 @@ main (int argc, char** argv)
   /* ---------------------------------------------------------------------- */
   /* initialize GLEW */
   glewExperimental = GL_TRUE;
-#ifdef GLEW_MX
-  err = glewContextInit(glewGetContext());
-#  ifdef _WIN32
-  err = err || wglewContextInit(wglewGetContext());
-#  elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX)
-  err = err || glxewContextInit(glxewGetContext());
-#  endif
-#else
   err = glewInit();
-#endif
   if (GLEW_OK != err)
   {
     fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
@@ -274,6 +263,7 @@ void PrintExtensions (const char* s)
 void
 VisualInfo (GLContext* ctx)
 {
+  (void) ctx; /* not used */
 }
 
 #elif defined(_WIN32)
@@ -1041,7 +1031,7 @@ GLboolean CreateContext (GLContext* ctx)
   {
     osmPixels = (GLubyte *) calloc(osmWidth*osmHeight*4, 1);
   }
-  if (!OSMesaMakeCurrent(ctx->ctx, osmPixels, GL_UNSIGNED_BYTE, osmWidth, osmHeight))
+  if (!OSMesaMakeCurrent(ctx->ctx, osmPixels, osmFormat, osmWidth, osmHeight))
   {
       return GL_TRUE;
   }
@@ -1063,13 +1053,13 @@ void InitContext (GLContext* ctx)
 
 GLboolean CreateContext (GLContext* ctx)
 {
+  (void) ctx; /* not used */
   return GL_FALSE;
 }
 
 void DestroyContext (GLContext* ctx)
 {
-  if (NULL == ctx) return;
-  return;
+  (void) ctx; /* not used */
 }
 
 /* ------------------------------------------------------------------------ */
diff --git a/3rdparty/vkmemalloc/vk_mem_alloc.h b/3rdparty/vkmemalloc/vk_mem_alloc.h
new file mode 100644
index 00000000000..60f572038c0
--- /dev/null
+++ b/3rdparty/vkmemalloc/vk_mem_alloc.h
@@ -0,0 +1,19558 @@
+//
+// Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
+#define AMD_VULKAN_MEMORY_ALLOCATOR_H
+
+/** \mainpage Vulkan Memory Allocator
+
+<b>Version 3.0.1 (2022-05-26)</b>
+
+Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved. \n
+License: MIT
+
+<b>API documentation divided into groups:</b> [Modules](modules.html)
+
+\section main_table_of_contents Table of contents
+
+- <b>User guide</b>
+  - \subpage quick_start
+    - [Project setup](@ref quick_start_project_setup)
+    - [Initialization](@ref quick_start_initialization)
+    - [Resource allocation](@ref quick_start_resource_allocation)
+  - \subpage choosing_memory_type
+    - [Usage](@ref choosing_memory_type_usage)
+    - [Required and preferred flags](@ref choosing_memory_type_required_preferred_flags)
+    - [Explicit memory types](@ref choosing_memory_type_explicit_memory_types)
+    - [Custom memory pools](@ref choosing_memory_type_custom_memory_pools)
+    - [Dedicated allocations](@ref choosing_memory_type_dedicated_allocations)
+  - \subpage memory_mapping
+    - [Mapping functions](@ref memory_mapping_mapping_functions)
+    - [Persistently mapped memory](@ref memory_mapping_persistently_mapped_memory)
+    - [Cache flush and invalidate](@ref memory_mapping_cache_control)
+  - \subpage staying_within_budget
+    - [Querying for budget](@ref staying_within_budget_querying_for_budget)
+    - [Controlling memory usage](@ref staying_within_budget_controlling_memory_usage)
+  - \subpage resource_aliasing
+  - \subpage custom_memory_pools
+    - [Choosing memory type index](@ref custom_memory_pools_MemTypeIndex)
+    - [Linear allocation algorithm](@ref linear_algorithm)
+      - [Free-at-once](@ref linear_algorithm_free_at_once)
+      - [Stack](@ref linear_algorithm_stack)
+      - [Double stack](@ref linear_algorithm_double_stack)
+      - [Ring buffer](@ref linear_algorithm_ring_buffer)
+  - \subpage defragmentation
+  - \subpage statistics
+    - [Numeric statistics](@ref statistics_numeric_statistics)
+    - [JSON dump](@ref statistics_json_dump)
+  - \subpage allocation_annotation
+    - [Allocation user data](@ref allocation_user_data)
+    - [Allocation names](@ref allocation_names)
+  - \subpage virtual_allocator
+  - \subpage debugging_memory_usage
+    - [Memory initialization](@ref debugging_memory_usage_initialization)
+    - [Margins](@ref debugging_memory_usage_margins)
+    - [Corruption detection](@ref debugging_memory_usage_corruption_detection)
+  - \subpage opengl_interop
+- \subpage usage_patterns
+    - [GPU-only resource](@ref usage_patterns_gpu_only)
+    - [Staging copy for upload](@ref usage_patterns_staging_copy_upload)
+    - [Readback](@ref usage_patterns_readback)
+    - [Advanced data uploading](@ref usage_patterns_advanced_data_uploading)
+    - [Other use cases](@ref usage_patterns_other_use_cases)
+- \subpage configuration
+  - [Pointers to Vulkan functions](@ref config_Vulkan_functions)
+  - [Custom host memory allocator](@ref custom_memory_allocator)
+  - [Device memory allocation callbacks](@ref allocation_callbacks)
+  - [Device heap memory limit](@ref heap_memory_limit)
+- <b>Extension support</b>
+    - \subpage vk_khr_dedicated_allocation
+    - \subpage enabling_buffer_device_address
+    - \subpage vk_ext_memory_priority
+    - \subpage vk_amd_device_coherent_memory
+- \subpage general_considerations
+  - [Thread safety](@ref general_considerations_thread_safety)
+  - [Versioning and compatibility](@ref general_considerations_versioning_and_compatibility)
+  - [Validation layer warnings](@ref general_considerations_validation_layer_warnings)
+  - [Allocation algorithm](@ref general_considerations_allocation_algorithm)
+  - [Features not supported](@ref general_considerations_features_not_supported)
+
+\section main_see_also See also
+
+- [**Product page on GPUOpen**](https://gpuopen.com/gaming-product/vulkan-memory-allocator/)
+- [**Source repository on GitHub**](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
+
+\defgroup group_init Library initialization
+
+\brief API elements related to the initialization and management of the entire library, especially #VmaAllocator object.
+
+\defgroup group_alloc Memory allocation
+
+\brief API elements related to the allocation, deallocation, and management of Vulkan memory, buffers, images.
+Most basic ones being: vmaCreateBuffer(), vmaCreateImage().
+
+\defgroup group_virtual Virtual allocator
+
+\brief API elements related to the mechanism of \ref virtual_allocator - using the core allocation algorithm
+for user-defined purpose without allocating any real GPU memory.
+
+\defgroup group_stats Statistics
+
+\brief API elements that query current status of the allocator, from memory usage, budget, to full dump of the internal state in JSON format.
+See documentation chapter: \ref statistics.
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef VULKAN_H_
+    #include <vulkan/vulkan.h>
+#endif
+
+// Define this macro to declare maximum supported Vulkan version in format AAABBBCCC,
+// where AAA = major, BBB = minor, CCC = patch.
+// If you want to use version > 1.0, it still needs to be enabled via VmaAllocatorCreateInfo::vulkanApiVersion.
+#if !defined(VMA_VULKAN_VERSION)
+    #if defined(VK_VERSION_1_3)
+        #define VMA_VULKAN_VERSION 1003000
+    #elif defined(VK_VERSION_1_2)
+        #define VMA_VULKAN_VERSION 1002000
+    #elif defined(VK_VERSION_1_1)
+        #define VMA_VULKAN_VERSION 1001000
+    #else
+        #define VMA_VULKAN_VERSION 1000000
+    #endif
+#endif
+
+#if defined(__ANDROID__) && defined(VK_NO_PROTOTYPES) && VMA_STATIC_VULKAN_FUNCTIONS
+    extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+    extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
+    extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
+    extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+    extern PFN_vkAllocateMemory vkAllocateMemory;
+    extern PFN_vkFreeMemory vkFreeMemory;
+    extern PFN_vkMapMemory vkMapMemory;
+    extern PFN_vkUnmapMemory vkUnmapMemory;
+    extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
+    extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
+    extern PFN_vkBindBufferMemory vkBindBufferMemory;
+    extern PFN_vkBindImageMemory vkBindImageMemory;
+    extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+    extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+    extern PFN_vkCreateBuffer vkCreateBuffer;
+    extern PFN_vkDestroyBuffer vkDestroyBuffer;
+    extern PFN_vkCreateImage vkCreateImage;
+    extern PFN_vkDestroyImage vkDestroyImage;
+    extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
+    #if VMA_VULKAN_VERSION >= 1001000
+        extern PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2;
+        extern PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2;
+        extern PFN_vkBindBufferMemory2 vkBindBufferMemory2;
+        extern PFN_vkBindImageMemory2 vkBindImageMemory2;
+        extern PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2;
+    #endif // #if VMA_VULKAN_VERSION >= 1001000
+#endif // #if defined(__ANDROID__) && VMA_STATIC_VULKAN_FUNCTIONS && VK_NO_PROTOTYPES
+
+#if !defined(VMA_DEDICATED_ALLOCATION)
+    #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
+        #define VMA_DEDICATED_ALLOCATION 1
+    #else
+        #define VMA_DEDICATED_ALLOCATION 0
+    #endif
+#endif
+
+#if !defined(VMA_BIND_MEMORY2)
+    #if VK_KHR_bind_memory2
+        #define VMA_BIND_MEMORY2 1
+    #else
+        #define VMA_BIND_MEMORY2 0
+    #endif
+#endif
+
+#if !defined(VMA_MEMORY_BUDGET)
+    #if VK_EXT_memory_budget && (VK_KHR_get_physical_device_properties2 || VMA_VULKAN_VERSION >= 1001000)
+        #define VMA_MEMORY_BUDGET 1
+    #else
+        #define VMA_MEMORY_BUDGET 0
+    #endif
+#endif
+
+// Defined to 1 when VK_KHR_buffer_device_address device extension or equivalent core Vulkan 1.2 feature is defined in its headers.
+#if !defined(VMA_BUFFER_DEVICE_ADDRESS)
+    #if VK_KHR_buffer_device_address || VMA_VULKAN_VERSION >= 1002000
+        #define VMA_BUFFER_DEVICE_ADDRESS 1
+    #else
+        #define VMA_BUFFER_DEVICE_ADDRESS 0
+    #endif
+#endif
+
+// Defined to 1 when VK_EXT_memory_priority device extension is defined in Vulkan headers.
+#if !defined(VMA_MEMORY_PRIORITY)
+    #if VK_EXT_memory_priority
+        #define VMA_MEMORY_PRIORITY 1
+    #else
+        #define VMA_MEMORY_PRIORITY 0
+    #endif
+#endif
+
+// Defined to 1 when VK_KHR_external_memory device extension is defined in Vulkan headers.
+#if !defined(VMA_EXTERNAL_MEMORY)
+    #if VK_KHR_external_memory
+        #define VMA_EXTERNAL_MEMORY 1
+    #else
+        #define VMA_EXTERNAL_MEMORY 0
+    #endif
+#endif
+
+// Define these macros to decorate all public functions with additional code,
+// before and after returned type, appropriately. This may be useful for
+// exporting the functions when compiling VMA as a separate library. Example:
+// #define VMA_CALL_PRE  __declspec(dllexport)
+// #define VMA_CALL_POST __cdecl
+#ifndef VMA_CALL_PRE
+    #define VMA_CALL_PRE
+#endif
+#ifndef VMA_CALL_POST
+    #define VMA_CALL_POST
+#endif
+
+// Define this macro to decorate pointers with an attribute specifying the
+// length of the array they point to if they are not null.
+//
+// The length may be one of
+// - The name of another parameter in the argument list where the pointer is declared
+// - The name of another member in the struct where the pointer is declared
+// - The name of a member of a struct type, meaning the value of that member in
+//   the context of the call. For example
+//   VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount"),
+//   this means the number of memory heaps available in the device associated
+//   with the VmaAllocator being dealt with.
+#ifndef VMA_LEN_IF_NOT_NULL
+    #define VMA_LEN_IF_NOT_NULL(len)
+#endif
+
+// The VMA_NULLABLE macro is defined to be _Nullable when compiling with Clang.
+// see: https://clang.llvm.org/docs/AttributeReference.html#nullable
+#ifndef VMA_NULLABLE
+    #ifdef __clang__
+        #define VMA_NULLABLE _Nullable
+    #else
+        #define VMA_NULLABLE
+    #endif
+#endif
+
+// The VMA_NOT_NULL macro is defined to be _Nonnull when compiling with Clang.
+// see: https://clang.llvm.org/docs/AttributeReference.html#nonnull
+#ifndef VMA_NOT_NULL
+    #ifdef __clang__
+        #define VMA_NOT_NULL _Nonnull
+    #else
+        #define VMA_NOT_NULL
+    #endif
+#endif
+
+// If non-dispatchable handles are represented as pointers then we can give
+// then nullability annotations
+#ifndef VMA_NOT_NULL_NON_DISPATCHABLE
+    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+        #define VMA_NOT_NULL_NON_DISPATCHABLE VMA_NOT_NULL
+    #else
+        #define VMA_NOT_NULL_NON_DISPATCHABLE
+    #endif
+#endif
+
+#ifndef VMA_NULLABLE_NON_DISPATCHABLE
+    #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+        #define VMA_NULLABLE_NON_DISPATCHABLE VMA_NULLABLE
+    #else
+        #define VMA_NULLABLE_NON_DISPATCHABLE
+    #endif
+#endif
+
+#ifndef VMA_STATS_STRING_ENABLED
+    #define VMA_STATS_STRING_ENABLED 1
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// 
+//    INTERFACE
+// 
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// Sections for managing code placement in file, only for development purposes e.g. for convenient folding inside an IDE.
+#ifndef _VMA_ENUM_DECLARATIONS
+
+/**
+\addtogroup group_init
+@{
+*/
+
+/// Flags for created #VmaAllocator.
+typedef enum VmaAllocatorCreateFlagBits
+{
+    /** \brief Allocator and all objects created from it will not be synchronized internally, so you must guarantee they are used from only one thread at a time or synchronized externally by you.
+
+    Using this flag may increase performance because internal mutexes are not used.
+    */
+    VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
+    /** \brief Enables usage of VK_KHR_dedicated_allocation extension.
+
+    The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_0`.
+    When it is `VK_API_VERSION_1_1`, the flag is ignored because the extension has been promoted to Vulkan 1.1.
+
+    Using this extension will automatically allocate dedicated blocks of memory for
+    some buffers and images instead of suballocating place for them out of bigger
+    memory blocks (as if you explicitly used #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
+    flag) when it is recommended by the driver. It may improve performance on some
+    GPUs.
+
+    You may set this flag only if you found out that following device extensions are
+    supported, you enabled them while creating Vulkan device passed as
+    VmaAllocatorCreateInfo::device, and you want them to be used internally by this
+    library:
+
+    - VK_KHR_get_memory_requirements2 (device extension)
+    - VK_KHR_dedicated_allocation (device extension)
+
+    When this flag is set, you can experience following warnings reported by Vulkan
+    validation layer. You can ignore them.
+
+    > vkBindBufferMemory(): Binding memory to buffer 0x2d but vkGetBufferMemoryRequirements() has not been called on that buffer.
+    */
+    VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
+    /**
+    Enables usage of VK_KHR_bind_memory2 extension.
+
+    The flag works only if VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_0`.
+    When it is `VK_API_VERSION_1_1`, the flag is ignored because the extension has been promoted to Vulkan 1.1.
+
+    You may set this flag only if you found out that this device extension is supported,
+    you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
+    and you want it to be used internally by this library.
+
+    The extension provides functions `vkBindBufferMemory2KHR` and `vkBindImageMemory2KHR`,
+    which allow to pass a chain of `pNext` structures while binding.
+    This flag is required if you use `pNext` parameter in vmaBindBufferMemory2() or vmaBindImageMemory2().
+    */
+    VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT = 0x00000004,
+    /**
+    Enables usage of VK_EXT_memory_budget extension.
+
+    You may set this flag only if you found out that this device extension is supported,
+    you enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
+    and you want it to be used internally by this library, along with another instance extension
+    VK_KHR_get_physical_device_properties2, which is required by it (or Vulkan 1.1, where this extension is promoted).
+
+    The extension provides query for current memory usage and budget, which will probably
+    be more accurate than an estimation used by the library otherwise.
+    */
+    VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT = 0x00000008,
+    /**
+    Enables usage of VK_AMD_device_coherent_memory extension.
+
+    You may set this flag only if you:
+
+    - found out that this device extension is supported and enabled it while creating Vulkan device passed as VmaAllocatorCreateInfo::device,
+    - checked that `VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory` is true and set it while creating the Vulkan device,
+    - want it to be used internally by this library.
+
+    The extension and accompanying device feature provide access to memory types with
+    `VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD` and `VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` flags.
+    They are useful mostly for writing breadcrumb markers - a common method for debugging GPU crash/hang/TDR.
+
+    When the extension is not enabled, such memory types are still enumerated, but their usage is illegal.
+    To protect from this error, if you don't create the allocator with this flag, it will refuse to allocate any memory or create a custom pool in such memory type,
+    returning `VK_ERROR_FEATURE_NOT_PRESENT`.
+    */
+    VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT = 0x00000010,
+    /**
+    Enables usage of "buffer device address" feature, which allows you to use function
+    `vkGetBufferDeviceAddress*` to get raw GPU pointer to a buffer and pass it for usage inside a shader.
+
+    You may set this flag only if you:
+
+    1. (For Vulkan version < 1.2) Found as available and enabled device extension
+    VK_KHR_buffer_device_address.
+    This extension is promoted to core Vulkan 1.2.
+    2. Found as available and enabled device feature `VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress`.
+
+    When this flag is set, you can create buffers with `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT` using VMA.
+    The library automatically adds `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT` to
+    allocated memory blocks wherever it might be needed.
+
+    For more information, see documentation chapter \ref enabling_buffer_device_address.
+    */
+    VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT = 0x00000020,
+    /**
+    Enables usage of VK_EXT_memory_priority extension in the library.
+
+    You may set this flag only if you found available and enabled this device extension,
+    along with `VkPhysicalDeviceMemoryPriorityFeaturesEXT::memoryPriority == VK_TRUE`,
+    while creating Vulkan device passed as VmaAllocatorCreateInfo::device.
+
+    When this flag is used, VmaAllocationCreateInfo::priority and VmaPoolCreateInfo::priority
+    are used to set priorities of allocated Vulkan memory. Without it, these variables are ignored.
+
+    A priority must be a floating-point value between 0 and 1, indicating the priority of the allocation relative to other memory allocations.
+    Larger values are higher priority. The granularity of the priorities is implementation-dependent.
+    It is automatically passed to every call to `vkAllocateMemory` done by the library using structure `VkMemoryPriorityAllocateInfoEXT`.
+    The value to be used for default priority is 0.5.
+    For more details, see the documentation of the VK_EXT_memory_priority extension.
+    */
+    VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT = 0x00000040,
+
+    VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaAllocatorCreateFlagBits;
+/// See #VmaAllocatorCreateFlagBits.
+typedef VkFlags VmaAllocatorCreateFlags;
+
+/** @} */
+
+/**
+\addtogroup group_alloc
+@{
+*/
+
+/// \brief Intended usage of the allocated memory.
+typedef enum VmaMemoryUsage
+{
+    /** No intended memory usage specified.
+    Use other members of VmaAllocationCreateInfo to specify your requirements.
+    */
+    VMA_MEMORY_USAGE_UNKNOWN = 0,
+    /**
+    \deprecated Obsolete, preserved for backward compatibility.
+    Prefers `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
+    */
+    VMA_MEMORY_USAGE_GPU_ONLY = 1,
+    /**
+    \deprecated Obsolete, preserved for backward compatibility.
+    Guarantees `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` and `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT`.
+    */
+    VMA_MEMORY_USAGE_CPU_ONLY = 2,
+    /**
+    \deprecated Obsolete, preserved for backward compatibility.
+    Guarantees `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`, prefers `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
+    */
+    VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
+    /**
+    \deprecated Obsolete, preserved for backward compatibility.
+    Guarantees `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`, prefers `VK_MEMORY_PROPERTY_HOST_CACHED_BIT`.
+    */
+    VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
+    /**
+    \deprecated Obsolete, preserved for backward compatibility.
+    Prefers not `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
+    */
+    VMA_MEMORY_USAGE_CPU_COPY = 5,
+    /**
+    Lazily allocated GPU memory having `VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT`.
+    Exists mostly on mobile platforms. Using it on desktop PC or other GPUs with no such memory type present will fail the allocation.
+
+    Usage: Memory for transient attachment images (color attachments, depth attachments etc.), created with `VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT`.
+
+    Allocations with this usage are always created as dedicated - it implies #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+    */
+    VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED = 6,
+    /**
+    Selects best memory type automatically.
+    This flag is recommended for most common use cases.
+
+    When using this flag, if you want to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT),
+    you must pass one of the flags: #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
+    in VmaAllocationCreateInfo::flags.
+    
+    It can be used only with functions that let the library know `VkBufferCreateInfo` or `VkImageCreateInfo`, e.g.
+    vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo()
+    and not with generic memory allocation functions.
+    */
+    VMA_MEMORY_USAGE_AUTO = 7,
+    /**
+    Selects best memory type automatically with preference for GPU (device) memory.
+
+    When using this flag, if you want to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT),
+    you must pass one of the flags: #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
+    in VmaAllocationCreateInfo::flags.
+
+    It can be used only with functions that let the library know `VkBufferCreateInfo` or `VkImageCreateInfo`, e.g.
+    vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo()
+    and not with generic memory allocation functions.
+    */
+    VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE = 8,
+    /**
+    Selects best memory type automatically with preference for CPU (host) memory.
+
+    When using this flag, if you want to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT),
+    you must pass one of the flags: #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
+    in VmaAllocationCreateInfo::flags.
+
+    It can be used only with functions that let the library know `VkBufferCreateInfo` or `VkImageCreateInfo`, e.g.
+    vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo()
+    and not with generic memory allocation functions.
+    */
+    VMA_MEMORY_USAGE_AUTO_PREFER_HOST = 9,
+
+    VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
+} VmaMemoryUsage;
+
+/// Flags to be passed as VmaAllocationCreateInfo::flags.
+typedef enum VmaAllocationCreateFlagBits
+{
+    /** \brief Set this flag if the allocation should have its own memory block.
+
+    Use it for special, big resources, like fullscreen images used as attachments.
+    */
+    VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
+
+    /** \brief Set this flag to only try to allocate from existing `VkDeviceMemory` blocks and never create new such block.
+
+    If new allocation cannot be placed in any of the existing blocks, allocation
+    fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY` error.
+
+    You should not use #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT and
+    #VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT at the same time. It makes no sense.
+    */
+    VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
+    /** \brief Set this flag to use a memory that will be persistently mapped and retrieve pointer to it.
+
+    Pointer to mapped memory will be returned through VmaAllocationInfo::pMappedData.
+
+    It is valid to use this flag for allocation made from memory type that is not
+    `HOST_VISIBLE`. This flag is then ignored and memory is not mapped. This is
+    useful if you need an allocation that is efficient to use on GPU
+    (`DEVICE_LOCAL`) and still want to map it directly if possible on platforms that
+    support it (e.g. Intel GPU).
+    */
+    VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
+    /** \deprecated Preserved for backward compatibility. Consider using vmaSetAllocationName() instead.
+    
+    Set this flag to treat VmaAllocationCreateInfo::pUserData as pointer to a
+    null-terminated string. Instead of copying pointer value, a local copy of the
+    string is made and stored in allocation's `pName`. The string is automatically
+    freed together with the allocation. It is also used in vmaBuildStatsString().
+    */
+    VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
+    /** Allocation will be created from upper stack in a double stack pool.
+
+    This flag is only allowed for custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT flag.
+    */
+    VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
+    /** Create both buffer/image and allocation, but don't bind them together.
+    It is useful when you want to bind yourself to do some more advanced binding, e.g. using some extensions.
+    The flag is meaningful only with functions that bind by default: vmaCreateBuffer(), vmaCreateImage().
+    Otherwise it is ignored.
+
+    If you want to make sure the new buffer/image is not tied to the new memory allocation
+    through `VkMemoryDedicatedAllocateInfoKHR` structure in case the allocation ends up in its own memory block,
+    use also flag #VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT.
+    */
+    VMA_ALLOCATION_CREATE_DONT_BIND_BIT = 0x00000080,
+    /** Create allocation only if additional device memory required for it, if any, won't exceed
+    memory budget. Otherwise return `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+    */
+    VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = 0x00000100,
+    /** \brief Set this flag if the allocated memory will have aliasing resources.
+    
+    Usage of this flag prevents supplying `VkMemoryDedicatedAllocateInfoKHR` when #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT is specified.
+    Otherwise created dedicated memory will not be suitable for aliasing resources, resulting in Vulkan Validation Layer errors.
+    */
+    VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT = 0x00000200,
+    /**
+    Requests possibility to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT).
+    
+    - If you use #VMA_MEMORY_USAGE_AUTO or other `VMA_MEMORY_USAGE_AUTO*` value,
+      you must use this flag to be able to map the allocation. Otherwise, mapping is incorrect.
+    - If you use other value of #VmaMemoryUsage, this flag is ignored and mapping is always possible in memory types that are `HOST_VISIBLE`.
+      This includes allocations created in \ref custom_memory_pools.
+
+    Declares that mapped memory will only be written sequentially, e.g. using `memcpy()` or a loop writing number-by-number,
+    never read or accessed randomly, so a memory type can be selected that is uncached and write-combined.
+
+    \warning Violating this declaration may work correctly, but will likely be very slow.
+    Watch out for implicit reads introduced by doing e.g. `pMappedData[i] += x;`
+    Better prepare your data in a local variable and `memcpy()` it to the mapped pointer all at once.
+    */
+    VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT = 0x00000400,
+    /**
+    Requests possibility to map the allocation (using vmaMapMemory() or #VMA_ALLOCATION_CREATE_MAPPED_BIT).
+    
+    - If you use #VMA_MEMORY_USAGE_AUTO or other `VMA_MEMORY_USAGE_AUTO*` value,
+      you must use this flag to be able to map the allocation. Otherwise, mapping is incorrect.
+    - If you use other value of #VmaMemoryUsage, this flag is ignored and mapping is always possible in memory types that are `HOST_VISIBLE`.
+      This includes allocations created in \ref custom_memory_pools.
+
+    Declares that mapped memory can be read, written, and accessed in random order,
+    so a `HOST_CACHED` memory type is required.
+    */
+    VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT = 0x00000800,
+    /**
+    Together with #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
+    it says that despite request for host access, a not-`HOST_VISIBLE` memory type can be selected
+    if it may improve performance.
+
+    By using this flag, you declare that you will check if the allocation ended up in a `HOST_VISIBLE` memory type
+    (e.g. using vmaGetAllocationMemoryProperties()) and if not, you will create some "staging" buffer and
+    issue an explicit transfer to write/read your data.
+    To prepare for this possibility, don't forget to add appropriate flags like
+    `VK_BUFFER_USAGE_TRANSFER_DST_BIT`, `VK_BUFFER_USAGE_TRANSFER_SRC_BIT` to the parameters of created buffer or image.
+    */
+    VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT = 0x00001000,
+    /** Allocation strategy that chooses smallest possible free range for the allocation
+    to minimize memory usage and fragmentation, possibly at the expense of allocation time.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = 0x00010000,
+    /** Allocation strategy that chooses first suitable free range for the allocation -
+    not necessarily in terms of the smallest offset but the one that is easiest and fastest to find
+    to minimize allocation time, possibly at the expense of allocation quality.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = 0x00020000,
+    /** Allocation strategy that chooses always the lowest offset in available space.
+    This is not the most efficient strategy but achieves highly packed data.
+    Used internally by defragmentation, not recomended in typical usage.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT  = 0x00040000,
+    /** Alias to #VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT,
+    /** Alias to #VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT,
+    /** A bit mask to extract only `STRATEGY` bits from entire set of flags.
+    */
+    VMA_ALLOCATION_CREATE_STRATEGY_MASK =
+        VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT |
+        VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT |
+        VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
+
+    VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaAllocationCreateFlagBits;
+/// See #VmaAllocationCreateFlagBits.
+typedef VkFlags VmaAllocationCreateFlags;
+
+/// Flags to be passed as VmaPoolCreateInfo::flags.
+typedef enum VmaPoolCreateFlagBits
+{
+    /** \brief Use this flag if you always allocate only buffers and linear images or only optimal images out of this pool and so Buffer-Image Granularity can be ignored.
+
+    This is an optional optimization flag.
+
+    If you always allocate using vmaCreateBuffer(), vmaCreateImage(),
+    vmaAllocateMemoryForBuffer(), then you don't need to use it because allocator
+    knows exact type of your allocations so it can handle Buffer-Image Granularity
+    in the optimal way.
+
+    If you also allocate using vmaAllocateMemoryForImage() or vmaAllocateMemory(),
+    exact type of such allocations is not known, so allocator must be conservative
+    in handling Buffer-Image Granularity, which can lead to suboptimal allocation
+    (wasted memory). In that case, if you can make sure you always allocate only
+    buffers and linear images or only optimal images out of this pool, use this flag
+    to make allocator disregard Buffer-Image Granularity and so make allocations
+    faster and more optimal.
+    */
+    VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
+
+    /** \brief Enables alternative, linear allocation algorithm in this pool.
+
+    Specify this flag to enable linear allocation algorithm, which always creates
+    new allocations after last one and doesn't reuse space from allocations freed in
+    between. It trades memory consumption for simplified algorithm and data
+    structure, which has better performance and uses less memory for metadata.
+
+    By using this flag, you can achieve behavior of free-at-once, stack,
+    ring buffer, and double stack.
+    For details, see documentation chapter \ref linear_algorithm.
+    */
+    VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
+
+    /** Bit mask to extract only `ALGORITHM` bits from entire set of flags.
+    */
+    VMA_POOL_CREATE_ALGORITHM_MASK =
+        VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT,
+
+    VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaPoolCreateFlagBits;
+/// Flags to be passed as VmaPoolCreateInfo::flags. See #VmaPoolCreateFlagBits.
+typedef VkFlags VmaPoolCreateFlags;
+
+/// Flags to be passed as VmaDefragmentationInfo::flags.
+typedef enum VmaDefragmentationFlagBits
+{
+    /* \brief Use simple but fast algorithm for defragmentation.
+    May not achieve best results but will require least time to compute and least allocations to copy.
+    */
+    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT = 0x1,
+    /* \brief Default defragmentation algorithm, applied also when no `ALGORITHM` flag is specified.
+    Offers a balance between defragmentation quality and the amount of allocations and bytes that need to be moved.
+    */
+    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT = 0x2,
+    /* \brief Perform full defragmentation of memory.
+    Can result in notably more time to compute and allocations to copy, but will achieve best memory packing.
+    */
+    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT = 0x4,
+    /** \brief Use the most roboust algorithm at the cost of time to compute and number of copies to make.
+    Only available when bufferImageGranularity is greater than 1, since it aims to reduce
+    alignment issues between different types of resources.
+    Otherwise falls back to same behavior as #VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT.
+    */
+    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT = 0x8,
+
+    /// A bit mask to extract only `ALGORITHM` bits from entire set of flags.
+    VMA_DEFRAGMENTATION_FLAG_ALGORITHM_MASK = 
+        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT |
+        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT |
+        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT |
+        VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT,
+
+    VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaDefragmentationFlagBits;
+/// See #VmaDefragmentationFlagBits.
+typedef VkFlags VmaDefragmentationFlags;
+
+/// Operation performed on single defragmentation move. See structure #VmaDefragmentationMove.
+typedef enum VmaDefragmentationMoveOperation
+{
+    /// Buffer/image has been recreated at `dstTmpAllocation`, data has been copied, old buffer/image has been destroyed. `srcAllocation` should be changed to point to the new place. This is the default value set by vmaBeginDefragmentationPass().
+    VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY = 0,
+    /// Set this value if you cannot move the allocation. New place reserved at `dstTmpAllocation` will be freed. `srcAllocation` will remain unchanged.
+    VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE = 1,
+    /// Set this value if you decide to abandon the allocation and you destroyed the buffer/image. New place reserved at `dstTmpAllocation` will be freed, along with `srcAllocation`, which will be destroyed.
+    VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY = 2,
+} VmaDefragmentationMoveOperation;
+
+/** @} */
+
+/**
+\addtogroup group_virtual
+@{
+*/
+
+/// Flags to be passed as VmaVirtualBlockCreateInfo::flags.
+typedef enum VmaVirtualBlockCreateFlagBits
+{
+    /** \brief Enables alternative, linear allocation algorithm in this virtual block.
+
+    Specify this flag to enable linear allocation algorithm, which always creates
+    new allocations after last one and doesn't reuse space from allocations freed in
+    between. It trades memory consumption for simplified algorithm and data
+    structure, which has better performance and uses less memory for metadata.
+
+    By using this flag, you can achieve behavior of free-at-once, stack,
+    ring buffer, and double stack.
+    For details, see documentation chapter \ref linear_algorithm.
+    */
+    VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT = 0x00000001,
+
+    /** \brief Bit mask to extract only `ALGORITHM` bits from entire set of flags.
+    */
+    VMA_VIRTUAL_BLOCK_CREATE_ALGORITHM_MASK =
+        VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT,
+
+    VMA_VIRTUAL_BLOCK_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaVirtualBlockCreateFlagBits;
+/// Flags to be passed as VmaVirtualBlockCreateInfo::flags. See #VmaVirtualBlockCreateFlagBits.
+typedef VkFlags VmaVirtualBlockCreateFlags;
+
+/// Flags to be passed as VmaVirtualAllocationCreateInfo::flags.
+typedef enum VmaVirtualAllocationCreateFlagBits
+{
+    /** \brief Allocation will be created from upper stack in a double stack pool.
+
+    This flag is only allowed for virtual blocks created with #VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT flag.
+    */
+    VMA_VIRTUAL_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT,
+    /** \brief Allocation strategy that tries to minimize memory usage.
+    */
+    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT,
+    /** \brief Allocation strategy that tries to minimize allocation time.
+    */
+    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT,
+    /** Allocation strategy that chooses always the lowest offset in available space.
+    This is not the most efficient strategy but achieves highly packed data.
+    */
+    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT = VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
+    /** \brief A bit mask to extract only `STRATEGY` bits from entire set of flags.
+
+    These strategy flags are binary compatible with equivalent flags in #VmaAllocationCreateFlagBits.
+    */
+    VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MASK = VMA_ALLOCATION_CREATE_STRATEGY_MASK,
+
+    VMA_VIRTUAL_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VmaVirtualAllocationCreateFlagBits;
+/// Flags to be passed as VmaVirtualAllocationCreateInfo::flags. See #VmaVirtualAllocationCreateFlagBits.
+typedef VkFlags VmaVirtualAllocationCreateFlags;
+
+/** @} */
+
+#endif // _VMA_ENUM_DECLARATIONS
+
+#ifndef _VMA_DATA_TYPES_DECLARATIONS
+
+/**
+\addtogroup group_init
+@{ */
+
+/** \struct VmaAllocator
+\brief Represents main object of this library initialized.
+
+Fill structure #VmaAllocatorCreateInfo and call function vmaCreateAllocator() to create it.
+Call function vmaDestroyAllocator() to destroy it.
+
+It is recommended to create just one object of this type per `VkDevice` object,
+right after Vulkan is initialized and keep it alive until before Vulkan device is destroyed.
+*/
+VK_DEFINE_HANDLE(VmaAllocator)
+
+/** @} */
+
+/**
+\addtogroup group_alloc
+@{
+*/
+
+/** \struct VmaPool
+\brief Represents custom memory pool
+
+Fill structure VmaPoolCreateInfo and call function vmaCreatePool() to create it.
+Call function vmaDestroyPool() to destroy it.
+
+For more information see [Custom memory pools](@ref choosing_memory_type_custom_memory_pools).
+*/
+VK_DEFINE_HANDLE(VmaPool)
+
+/** \struct VmaAllocation
+\brief Represents single memory allocation.
+
+It may be either dedicated block of `VkDeviceMemory` or a specific region of a bigger block of this type
+plus unique offset.
+
+There are multiple ways to create such object.
+You need to fill structure VmaAllocationCreateInfo.
+For more information see [Choosing memory type](@ref choosing_memory_type).
+
+Although the library provides convenience functions that create Vulkan buffer or image,
+allocate memory for it and bind them together,
+binding of the allocation to a buffer or an image is out of scope of the allocation itself.
+Allocation object can exist without buffer/image bound,
+binding can be done manually by the user, and destruction of it can be done
+independently of destruction of the allocation.
+
+The object also remembers its size and some other information.
+To retrieve this information, use function vmaGetAllocationInfo() and inspect
+returned structure VmaAllocationInfo.
+*/
+VK_DEFINE_HANDLE(VmaAllocation)
+
+/** \struct VmaDefragmentationContext
+\brief An opaque object that represents started defragmentation process.
+
+Fill structure #VmaDefragmentationInfo and call function vmaBeginDefragmentation() to create it.
+Call function vmaEndDefragmentation() to destroy it.
+*/
+VK_DEFINE_HANDLE(VmaDefragmentationContext)
+
+/** @} */
+
+/**
+\addtogroup group_virtual
+@{
+*/
+
+/** \struct VmaVirtualAllocation
+\brief Represents single memory allocation done inside VmaVirtualBlock.
+
+Use it as a unique identifier to virtual allocation within the single block.
+
+Use value `VK_NULL_HANDLE` to represent a null/invalid allocation.
+*/
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VmaVirtualAllocation);
+
+/** @} */
+
+/**
+\addtogroup group_virtual
+@{
+*/
+
+/** \struct VmaVirtualBlock
+\brief Handle to a virtual block object that allows to use core allocation algorithm without allocating any real GPU memory.
+
+Fill in #VmaVirtualBlockCreateInfo structure and use vmaCreateVirtualBlock() to create it. Use vmaDestroyVirtualBlock() to destroy it.
+For more information, see documentation chapter \ref virtual_allocator.
+
+This object is not thread-safe - should not be used from multiple threads simultaneously, must be synchronized externally.
+*/
+VK_DEFINE_HANDLE(VmaVirtualBlock)
+
+/** @} */
+
+/**
+\addtogroup group_init
+@{
+*/
+
+/// Callback function called after successful vkAllocateMemory.
+typedef void (VKAPI_PTR* PFN_vmaAllocateDeviceMemoryFunction)(
+    VmaAllocator VMA_NOT_NULL                    allocator,
+    uint32_t                                     memoryType,
+    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory,
+    VkDeviceSize                                 size,
+    void* VMA_NULLABLE                           pUserData);
+
+/// Callback function called before vkFreeMemory.
+typedef void (VKAPI_PTR* PFN_vmaFreeDeviceMemoryFunction)(
+    VmaAllocator VMA_NOT_NULL                    allocator,
+    uint32_t                                     memoryType,
+    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory,
+    VkDeviceSize                                 size,
+    void* VMA_NULLABLE                           pUserData);
+
+/** \brief Set of callbacks that the library will call for `vkAllocateMemory` and `vkFreeMemory`.
+
+Provided for informative purpose, e.g. to gather statistics about number of
+allocations or total amount of memory allocated in Vulkan.
+
+Used in VmaAllocatorCreateInfo::pDeviceMemoryCallbacks.
+*/
+typedef struct VmaDeviceMemoryCallbacks
+{
+    /// Optional, can be null.
+    PFN_vmaAllocateDeviceMemoryFunction VMA_NULLABLE pfnAllocate;
+    /// Optional, can be null.
+    PFN_vmaFreeDeviceMemoryFunction VMA_NULLABLE pfnFree;
+    /// Optional, can be null.
+    void* VMA_NULLABLE pUserData;
+} VmaDeviceMemoryCallbacks;
+
+/** \brief Pointers to some Vulkan functions - a subset used by the library.
+
+Used in VmaAllocatorCreateInfo::pVulkanFunctions.
+*/
+typedef struct VmaVulkanFunctions
+{
+    /// Required when using VMA_DYNAMIC_VULKAN_FUNCTIONS.
+    PFN_vkGetInstanceProcAddr VMA_NULLABLE vkGetInstanceProcAddr;
+    /// Required when using VMA_DYNAMIC_VULKAN_FUNCTIONS.
+    PFN_vkGetDeviceProcAddr VMA_NULLABLE vkGetDeviceProcAddr;
+    PFN_vkGetPhysicalDeviceProperties VMA_NULLABLE vkGetPhysicalDeviceProperties;
+    PFN_vkGetPhysicalDeviceMemoryProperties VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties;
+    PFN_vkAllocateMemory VMA_NULLABLE vkAllocateMemory;
+    PFN_vkFreeMemory VMA_NULLABLE vkFreeMemory;
+    PFN_vkMapMemory VMA_NULLABLE vkMapMemory;
+    PFN_vkUnmapMemory VMA_NULLABLE vkUnmapMemory;
+    PFN_vkFlushMappedMemoryRanges VMA_NULLABLE vkFlushMappedMemoryRanges;
+    PFN_vkInvalidateMappedMemoryRanges VMA_NULLABLE vkInvalidateMappedMemoryRanges;
+    PFN_vkBindBufferMemory VMA_NULLABLE vkBindBufferMemory;
+    PFN_vkBindImageMemory VMA_NULLABLE vkBindImageMemory;
+    PFN_vkGetBufferMemoryRequirements VMA_NULLABLE vkGetBufferMemoryRequirements;
+    PFN_vkGetImageMemoryRequirements VMA_NULLABLE vkGetImageMemoryRequirements;
+    PFN_vkCreateBuffer VMA_NULLABLE vkCreateBuffer;
+    PFN_vkDestroyBuffer VMA_NULLABLE vkDestroyBuffer;
+    PFN_vkCreateImage VMA_NULLABLE vkCreateImage;
+    PFN_vkDestroyImage VMA_NULLABLE vkDestroyImage;
+    PFN_vkCmdCopyBuffer VMA_NULLABLE vkCmdCopyBuffer;
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    /// Fetch "vkGetBufferMemoryRequirements2" on Vulkan >= 1.1, fetch "vkGetBufferMemoryRequirements2KHR" when using VK_KHR_dedicated_allocation extension.
+    PFN_vkGetBufferMemoryRequirements2KHR VMA_NULLABLE vkGetBufferMemoryRequirements2KHR;
+    /// Fetch "vkGetImageMemoryRequirements2" on Vulkan >= 1.1, fetch "vkGetImageMemoryRequirements2KHR" when using VK_KHR_dedicated_allocation extension.
+    PFN_vkGetImageMemoryRequirements2KHR VMA_NULLABLE vkGetImageMemoryRequirements2KHR;
+#endif
+#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
+    /// Fetch "vkBindBufferMemory2" on Vulkan >= 1.1, fetch "vkBindBufferMemory2KHR" when using VK_KHR_bind_memory2 extension.
+    PFN_vkBindBufferMemory2KHR VMA_NULLABLE vkBindBufferMemory2KHR;
+    /// Fetch "vkBindImageMemory2" on Vulkan >= 1.1, fetch "vkBindImageMemory2KHR" when using VK_KHR_bind_memory2 extension.
+    PFN_vkBindImageMemory2KHR VMA_NULLABLE vkBindImageMemory2KHR;
+#endif
+#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
+    PFN_vkGetPhysicalDeviceMemoryProperties2KHR VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties2KHR;
+#endif
+#if VMA_VULKAN_VERSION >= 1003000
+    /// Fetch from "vkGetDeviceBufferMemoryRequirements" on Vulkan >= 1.3, but you can also fetch it from "vkGetDeviceBufferMemoryRequirementsKHR" if you enabled extension VK_KHR_maintenance4.
+    PFN_vkGetDeviceBufferMemoryRequirements VMA_NULLABLE vkGetDeviceBufferMemoryRequirements;
+    /// Fetch from "vkGetDeviceImageMemoryRequirements" on Vulkan >= 1.3, but you can also fetch it from "vkGetDeviceImageMemoryRequirementsKHR" if you enabled extension VK_KHR_maintenance4.
+    PFN_vkGetDeviceImageMemoryRequirements VMA_NULLABLE vkGetDeviceImageMemoryRequirements;
+#endif
+} VmaVulkanFunctions;
+
+/// Description of a Allocator to be created.
+typedef struct VmaAllocatorCreateInfo
+{
+    /// Flags for created allocator. Use #VmaAllocatorCreateFlagBits enum.
+    VmaAllocatorCreateFlags flags;
+    /// Vulkan physical device.
+    /** It must be valid throughout whole lifetime of created allocator. */
+    VkPhysicalDevice VMA_NOT_NULL physicalDevice;
+    /// Vulkan device.
+    /** It must be valid throughout whole lifetime of created allocator. */
+    VkDevice VMA_NOT_NULL device;
+    /// Preferred size of a single `VkDeviceMemory` block to be allocated from large heaps > 1 GiB. Optional.
+    /** Set to 0 to use default, which is currently 256 MiB. */
+    VkDeviceSize preferredLargeHeapBlockSize;
+    /// Custom CPU memory allocation callbacks. Optional.
+    /** Optional, can be null. When specified, will also be used for all CPU-side memory allocations. */
+    const VkAllocationCallbacks* VMA_NULLABLE pAllocationCallbacks;
+    /// Informative callbacks for `vkAllocateMemory`, `vkFreeMemory`. Optional.
+    /** Optional, can be null. */
+    const VmaDeviceMemoryCallbacks* VMA_NULLABLE pDeviceMemoryCallbacks;
+    /** \brief Either null or a pointer to an array of limits on maximum number of bytes that can be allocated out of particular Vulkan memory heap.
+
+    If not NULL, it must be a pointer to an array of
+    `VkPhysicalDeviceMemoryProperties::memoryHeapCount` elements, defining limit on
+    maximum number of bytes that can be allocated out of particular Vulkan memory
+    heap.
+
+    Any of the elements may be equal to `VK_WHOLE_SIZE`, which means no limit on that
+    heap. This is also the default in case of `pHeapSizeLimit` = NULL.
+
+    If there is a limit defined for a heap:
+
+    - If user tries to allocate more memory from that heap using this allocator,
+      the allocation fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+    - If the limit is smaller than heap size reported in `VkMemoryHeap::size`, the
+      value of this limit will be reported instead when using vmaGetMemoryProperties().
+
+    Warning! Using this feature may not be equivalent to installing a GPU with
+    smaller amount of memory, because graphics driver doesn't necessary fail new
+    allocations with `VK_ERROR_OUT_OF_DEVICE_MEMORY` result when memory capacity is
+    exceeded. It may return success and just silently migrate some device memory
+    blocks to system RAM. This driver behavior can also be controlled using
+    VK_AMD_memory_overallocation_behavior extension.
+    */
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount") pHeapSizeLimit;
+
+    /** \brief Pointers to Vulkan functions. Can be null.
+
+    For details see [Pointers to Vulkan functions](@ref config_Vulkan_functions).
+    */
+    const VmaVulkanFunctions* VMA_NULLABLE pVulkanFunctions;
+    /** \brief Handle to Vulkan instance object.
+
+    Starting from version 3.0.0 this member is no longer optional, it must be set!
+    */
+    VkInstance VMA_NOT_NULL instance;
+    /** \brief Optional. The highest version of Vulkan that the application is designed to use.
+
+    It must be a value in the format as created by macro `VK_MAKE_VERSION` or a constant like: `VK_API_VERSION_1_1`, `VK_API_VERSION_1_0`.
+    The patch version number specified is ignored. Only the major and minor versions are considered.
+    It must be less or equal (preferably equal) to value as passed to `vkCreateInstance` as `VkApplicationInfo::apiVersion`.
+    Only versions 1.0, 1.1, 1.2, 1.3 are supported by the current implementation.
+    Leaving it initialized to zero is equivalent to `VK_API_VERSION_1_0`.
+    */
+    uint32_t vulkanApiVersion;
+#if VMA_EXTERNAL_MEMORY
+    /** \brief Either null or a pointer to an array of external memory handle types for each Vulkan memory type.
+
+    If not NULL, it must be a pointer to an array of `VkPhysicalDeviceMemoryProperties::memoryTypeCount`
+    elements, defining external memory handle types of particular Vulkan memory type,
+    to be passed using `VkExportMemoryAllocateInfoKHR`.
+
+    Any of the elements may be equal to 0, which means not to use `VkExportMemoryAllocateInfoKHR` on this memory type.
+    This is also the default in case of `pTypeExternalMemoryHandleTypes` = NULL.
+    */
+    const VkExternalMemoryHandleTypeFlagsKHR* VMA_NULLABLE VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryTypeCount") pTypeExternalMemoryHandleTypes;
+#endif // #if VMA_EXTERNAL_MEMORY
+} VmaAllocatorCreateInfo;
+
+/// Information about existing #VmaAllocator object.
+typedef struct VmaAllocatorInfo
+{
+    /** \brief Handle to Vulkan instance object.
+
+    This is the same value as has been passed through VmaAllocatorCreateInfo::instance.
+    */
+    VkInstance VMA_NOT_NULL instance;
+    /** \brief Handle to Vulkan physical device object.
+
+    This is the same value as has been passed through VmaAllocatorCreateInfo::physicalDevice.
+    */
+    VkPhysicalDevice VMA_NOT_NULL physicalDevice;
+    /** \brief Handle to Vulkan device object.
+
+    This is the same value as has been passed through VmaAllocatorCreateInfo::device.
+    */
+    VkDevice VMA_NOT_NULL device;
+} VmaAllocatorInfo;
+
+/** @} */
+
+/**
+\addtogroup group_stats
+@{
+*/
+
+/** \brief Calculated statistics of memory usage e.g. in a specific memory type, heap, custom pool, or total.
+
+These are fast to calculate.
+See functions: vmaGetHeapBudgets(), vmaGetPoolStatistics().
+*/
+typedef struct VmaStatistics
+{
+    /** \brief Number of `VkDeviceMemory` objects - Vulkan memory blocks allocated.
+    */
+    uint32_t blockCount;
+    /** \brief Number of #VmaAllocation objects allocated.
+    
+    Dedicated allocations have their own blocks, so each one adds 1 to `allocationCount` as well as `blockCount`.
+    */
+    uint32_t allocationCount;
+    /** \brief Number of bytes allocated in `VkDeviceMemory` blocks.
+    
+    \note To avoid confusion, please be aware that what Vulkan calls an "allocation" - a whole `VkDeviceMemory` object
+    (e.g. as in `VkPhysicalDeviceLimits::maxMemoryAllocationCount`) is called a "block" in VMA, while VMA calls
+    "allocation" a #VmaAllocation object that represents a memory region sub-allocated from such block, usually for a single buffer or image.
+    */
+    VkDeviceSize blockBytes;
+    /** \brief Total number of bytes occupied by all #VmaAllocation objects.
+    
+    Always less or equal than `blockBytes`.
+    Difference `(blockBytes - allocationBytes)` is the amount of memory allocated from Vulkan
+    but unused by any #VmaAllocation.
+    */
+    VkDeviceSize allocationBytes;
+} VmaStatistics;
+
+/** \brief More detailed statistics than #VmaStatistics.
+
+These are slower to calculate. Use for debugging purposes.
+See functions: vmaCalculateStatistics(), vmaCalculatePoolStatistics().
+
+Previous version of the statistics API provided averages, but they have been removed
+because they can be easily calculated as:
+
+\code
+VkDeviceSize allocationSizeAvg = detailedStats.statistics.allocationBytes / detailedStats.statistics.allocationCount;
+VkDeviceSize unusedBytes = detailedStats.statistics.blockBytes - detailedStats.statistics.allocationBytes;
+VkDeviceSize unusedRangeSizeAvg = unusedBytes / detailedStats.unusedRangeCount;
+\endcode
+*/
+typedef struct VmaDetailedStatistics
+{
+    /// Basic statistics.
+    VmaStatistics statistics;
+    /// Number of free ranges of memory between allocations.
+    uint32_t unusedRangeCount;
+    /// Smallest allocation size. `VK_WHOLE_SIZE` if there are 0 allocations.
+    VkDeviceSize allocationSizeMin;
+    /// Largest allocation size. 0 if there are 0 allocations.
+    VkDeviceSize allocationSizeMax;
+    /// Smallest empty range size. `VK_WHOLE_SIZE` if there are 0 empty ranges.
+    VkDeviceSize unusedRangeSizeMin;
+    /// Largest empty range size. 0 if there are 0 empty ranges.
+    VkDeviceSize unusedRangeSizeMax;
+} VmaDetailedStatistics;
+
+/** \brief  General statistics from current state of the Allocator -
+total memory usage across all memory heaps and types.
+
+These are slower to calculate. Use for debugging purposes.
+See function vmaCalculateStatistics().
+*/
+typedef struct VmaTotalStatistics
+{
+    VmaDetailedStatistics memoryType[VK_MAX_MEMORY_TYPES];
+    VmaDetailedStatistics memoryHeap[VK_MAX_MEMORY_HEAPS];
+    VmaDetailedStatistics total;
+} VmaTotalStatistics;
+
+/** \brief Statistics of current memory usage and available budget for a specific memory heap.
+
+These are fast to calculate.
+See function vmaGetHeapBudgets().
+*/
+typedef struct VmaBudget
+{
+    /** \brief Statistics fetched from the library.
+    */
+    VmaStatistics statistics;
+    /** \brief Estimated current memory usage of the program, in bytes.
+
+    Fetched from system using VK_EXT_memory_budget extension if enabled.
+
+    It might be different than `statistics.blockBytes` (usually higher) due to additional implicit objects
+    also occupying the memory, like swapchain, pipelines, descriptor heaps, command buffers, or
+    `VkDeviceMemory` blocks allocated outside of this library, if any.
+    */
+    VkDeviceSize usage;
+    /** \brief Estimated amount of memory available to the program, in bytes.
+
+    Fetched from system using VK_EXT_memory_budget extension if enabled.
+
+    It might be different (most probably smaller) than `VkMemoryHeap::size[heapIndex]` due to factors
+    external to the program, decided by the operating system.
+    Difference `budget - usage` is the amount of additional memory that can probably
+    be allocated without problems. Exceeding the budget may result in various problems.
+    */
+    VkDeviceSize budget;
+} VmaBudget;
+
+/** @} */
+
+/**
+\addtogroup group_alloc
+@{
+*/
+
+/** \brief Parameters of new #VmaAllocation.
+
+To be used with functions like vmaCreateBuffer(), vmaCreateImage(), and many others.
+*/
+typedef struct VmaAllocationCreateInfo
+{
+    /// Use #VmaAllocationCreateFlagBits enum.
+    VmaAllocationCreateFlags flags;
+    /** \brief Intended usage of memory.
+
+    You can leave #VMA_MEMORY_USAGE_UNKNOWN if you specify memory requirements in other way. \n
+    If `pool` is not null, this member is ignored.
+    */
+    VmaMemoryUsage usage;
+    /** \brief Flags that must be set in a Memory Type chosen for an allocation.
+
+    Leave 0 if you specify memory requirements in other way. \n
+    If `pool` is not null, this member is ignored.*/
+    VkMemoryPropertyFlags requiredFlags;
+    /** \brief Flags that preferably should be set in a memory type chosen for an allocation.
+
+    Set to 0 if no additional flags are preferred. \n
+    If `pool` is not null, this member is ignored. */
+    VkMemoryPropertyFlags preferredFlags;
+    /** \brief Bitmask containing one bit set for every memory type acceptable for this allocation.
+
+    Value 0 is equivalent to `UINT32_MAX` - it means any memory type is accepted if
+    it meets other requirements specified by this structure, with no further
+    restrictions on memory type index. \n
+    If `pool` is not null, this member is ignored.
+    */
+    uint32_t memoryTypeBits;
+    /** \brief Pool that this allocation should be created in.
+
+    Leave `VK_NULL_HANDLE` to allocate from default pool. If not null, members:
+    `usage`, `requiredFlags`, `preferredFlags`, `memoryTypeBits` are ignored.
+    */
+    VmaPool VMA_NULLABLE pool;
+    /** \brief Custom general-purpose pointer that will be stored in #VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData().
+
+    If #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT is used, it must be either
+    null or pointer to a null-terminated string. The string will be then copied to
+    internal buffer, so it doesn't need to be valid after allocation call.
+    */
+    void* VMA_NULLABLE pUserData;
+    /** \brief A floating-point value between 0 and 1, indicating the priority of the allocation relative to other memory allocations.
+
+    It is used only when #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT flag was used during creation of the #VmaAllocator object
+    and this allocation ends up as dedicated or is explicitly forced as dedicated using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+    Otherwise, it has the priority of a memory block where it is placed and this variable is ignored.
+    */
+    float priority;
+} VmaAllocationCreateInfo;
+
+/// Describes parameter of created #VmaPool.
+typedef struct VmaPoolCreateInfo
+{
+    /** \brief Vulkan memory type index to allocate this pool from.
+    */
+    uint32_t memoryTypeIndex;
+    /** \brief Use combination of #VmaPoolCreateFlagBits.
+    */
+    VmaPoolCreateFlags flags;
+    /** \brief Size of a single `VkDeviceMemory` block to be allocated as part of this pool, in bytes. Optional.
+
+    Specify nonzero to set explicit, constant size of memory blocks used by this
+    pool.
+
+    Leave 0 to use default and let the library manage block sizes automatically.
+    Sizes of particular blocks may vary.
+    In this case, the pool will also support dedicated allocations.
+    */
+    VkDeviceSize blockSize;
+    /** \brief Minimum number of blocks to be always allocated in this pool, even if they stay empty.
+
+    Set to 0 to have no preallocated blocks and allow the pool be completely empty.
+    */
+    size_t minBlockCount;
+    /** \brief Maximum number of blocks that can be allocated in this pool. Optional.
+
+    Set to 0 to use default, which is `SIZE_MAX`, which means no limit.
+
+    Set to same value as VmaPoolCreateInfo::minBlockCount to have fixed amount of memory allocated
+    throughout whole lifetime of this pool.
+    */
+    size_t maxBlockCount;
+    /** \brief A floating-point value between 0 and 1, indicating the priority of the allocations in this pool relative to other memory allocations.
+
+    It is used only when #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT flag was used during creation of the #VmaAllocator object.
+    Otherwise, this variable is ignored.
+    */
+    float priority;
+    /** \brief Additional minimum alignment to be used for all allocations created from this pool. Can be 0.
+
+    Leave 0 (default) not to impose any additional alignment. If not 0, it must be a power of two.
+    It can be useful in cases where alignment returned by Vulkan by functions like `vkGetBufferMemoryRequirements` is not enough,
+    e.g. when doing interop with OpenGL.
+    */
+    VkDeviceSize minAllocationAlignment;
+    /** \brief Additional `pNext` chain to be attached to `VkMemoryAllocateInfo` used for every allocation made by this pool. Optional.
+
+    Optional, can be null. If not null, it must point to a `pNext` chain of structures that can be attached to `VkMemoryAllocateInfo`.
+    It can be useful for special needs such as adding `VkExportMemoryAllocateInfoKHR`.
+    Structures pointed by this member must remain alive and unchanged for the whole lifetime of the custom pool.
+
+    Please note that some structures, e.g. `VkMemoryPriorityAllocateInfoEXT`, `VkMemoryDedicatedAllocateInfoKHR`,
+    can be attached automatically by this library when using other, more convenient of its features.
+    */
+    void* VMA_NULLABLE pMemoryAllocateNext;
+} VmaPoolCreateInfo;
+
+/** @} */
+
+/**
+\addtogroup group_alloc
+@{
+*/
+
+/// Parameters of #VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
+typedef struct VmaAllocationInfo
+{
+    /** \brief Memory type index that this allocation was allocated from.
+
+    It never changes.
+    */
+    uint32_t memoryType;
+    /** \brief Handle to Vulkan memory object.
+
+    Same memory object can be shared by multiple allocations.
+
+    It can change after the allocation is moved during \ref defragmentation.
+    */
+    VkDeviceMemory VMA_NULLABLE_NON_DISPATCHABLE deviceMemory;
+    /** \brief Offset in `VkDeviceMemory` object to the beginning of this allocation, in bytes. `(deviceMemory, offset)` pair is unique to this allocation.
+
+    You usually don't need to use this offset. If you create a buffer or an image together with the allocation using e.g. function
+    vmaCreateBuffer(), vmaCreateImage(), functions that operate on these resources refer to the beginning of the buffer or image,
+    not entire device memory block. Functions like vmaMapMemory(), vmaBindBufferMemory() also refer to the beginning of the allocation
+    and apply this offset automatically.
+
+    It can change after the allocation is moved during \ref defragmentation.
+    */
+    VkDeviceSize offset;
+    /** \brief Size of this allocation, in bytes.
+
+    It never changes.
+
+    \note Allocation size returned in this variable may be greater than the size
+    requested for the resource e.g. as `VkBufferCreateInfo::size`. Whole size of the
+    allocation is accessible for operations on memory e.g. using a pointer after
+    mapping with vmaMapMemory(), but operations on the resource e.g. using
+    `vkCmdCopyBuffer` must be limited to the size of the resource.
+    */
+    VkDeviceSize size;
+    /** \brief Pointer to the beginning of this allocation as mapped data.
+
+    If the allocation hasn't been mapped using vmaMapMemory() and hasn't been
+    created with #VMA_ALLOCATION_CREATE_MAPPED_BIT flag, this value is null.
+
+    It can change after call to vmaMapMemory(), vmaUnmapMemory().
+    It can also change after the allocation is moved during \ref defragmentation.
+    */
+    void* VMA_NULLABLE pMappedData;
+    /** \brief Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData().
+
+    It can change after call to vmaSetAllocationUserData() for this allocation.
+    */
+    void* VMA_NULLABLE pUserData;
+    /** \brief Custom allocation name that was set with vmaSetAllocationName().
+    
+    It can change after call to vmaSetAllocationName() for this allocation.
+    
+    Another way to set custom name is to pass it in VmaAllocationCreateInfo::pUserData with
+    additional flag #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT set [DEPRECATED].
+    */
+    const char* VMA_NULLABLE pName;
+} VmaAllocationInfo;
+
+/** \brief Parameters for defragmentation.
+
+To be used with function vmaBeginDefragmentation().
+*/
+typedef struct VmaDefragmentationInfo
+{
+    /// \brief Use combination of #VmaDefragmentationFlagBits.
+    VmaDefragmentationFlags flags;
+    /** \brief Custom pool to be defragmented.
+
+    If null then default pools will undergo defragmentation process.
+    */
+    VmaPool VMA_NULLABLE pool;
+    /** \brief Maximum numbers of bytes that can be copied during single pass, while moving allocations to different places.
+
+    `0` means no limit.
+    */
+    VkDeviceSize maxBytesPerPass;
+    /** \brief Maximum number of allocations that can be moved during single pass to a different place.
+
+    `0` means no limit.
+    */
+    uint32_t maxAllocationsPerPass;
+} VmaDefragmentationInfo;
+
+/// Single move of an allocation to be done for defragmentation.
+typedef struct VmaDefragmentationMove
+{
+    /// Operation to be performed on the allocation by vmaEndDefragmentationPass(). Default value is #VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY. You can modify it.
+    VmaDefragmentationMoveOperation operation;
+    /// Allocation that should be moved.
+    VmaAllocation VMA_NOT_NULL srcAllocation;
+    /** \brief Temporary allocation pointing to destination memory that will replace `srcAllocation`.
+    
+    \warning Do not store this allocation in your data structures! It exists only temporarily, for the duration of the defragmentation pass,
+    to be used for binding new buffer/image to the destination memory using e.g. vmaBindBufferMemory().
+    vmaEndDefragmentationPass() will destroy it and make `srcAllocation` point to this memory.
+    */
+    VmaAllocation VMA_NOT_NULL dstTmpAllocation;
+} VmaDefragmentationMove;
+
+/** \brief Parameters for incremental defragmentation steps.
+
+To be used with function vmaBeginDefragmentationPass().
+*/
+typedef struct VmaDefragmentationPassMoveInfo
+{
+    /// Number of elements in the `pMoves` array.
+    uint32_t moveCount;
+    /** \brief Array of moves to be performed by the user in the current defragmentation pass.
+    
+    Pointer to an array of `moveCount` elements, owned by VMA, created in vmaBeginDefragmentationPass(), destroyed in vmaEndDefragmentationPass().
+
+    For each element, you should:
+    
+    1. Create a new buffer/image in the place pointed by VmaDefragmentationMove::dstMemory + VmaDefragmentationMove::dstOffset.
+    2. Copy data from the VmaDefragmentationMove::srcAllocation e.g. using `vkCmdCopyBuffer`, `vkCmdCopyImage`.
+    3. Make sure these commands finished executing on the GPU.
+    4. Destroy the old buffer/image.
+    
+    Only then you can finish defragmentation pass by calling vmaEndDefragmentationPass().
+    After this call, the allocation will point to the new place in memory.
+
+    Alternatively, if you cannot move specific allocation, you can set VmaDefragmentationMove::operation to #VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
+
+    Alternatively, if you decide you want to completely remove the allocation:
+
+    1. Destroy its buffer/image.
+    2. Set VmaDefragmentationMove::operation to #VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY.
+
+    Then, after vmaEndDefragmentationPass() the allocation will be freed.
+    */
+    VmaDefragmentationMove* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(moveCount) pMoves;
+} VmaDefragmentationPassMoveInfo;
+
+/// Statistics returned for defragmentation process in function vmaEndDefragmentation().
+typedef struct VmaDefragmentationStats
+{
+    /// Total number of bytes that have been copied while moving allocations to different places.
+    VkDeviceSize bytesMoved;
+    /// Total number of bytes that have been released to the system by freeing empty `VkDeviceMemory` objects.
+    VkDeviceSize bytesFreed;
+    /// Number of allocations that have been moved to different places.
+    uint32_t allocationsMoved;
+    /// Number of empty `VkDeviceMemory` objects that have been released to the system.
+    uint32_t deviceMemoryBlocksFreed;
+} VmaDefragmentationStats;
+
+/** @} */
+
+/**
+\addtogroup group_virtual
+@{
+*/
+
+/// Parameters of created #VmaVirtualBlock object to be passed to vmaCreateVirtualBlock().
+typedef struct VmaVirtualBlockCreateInfo
+{
+    /** \brief Total size of the virtual block.
+
+    Sizes can be expressed in bytes or any units you want as long as you are consistent in using them.
+    For example, if you allocate from some array of structures, 1 can mean single instance of entire structure.
+    */
+    VkDeviceSize size;
+
+    /** \brief Use combination of #VmaVirtualBlockCreateFlagBits.
+    */
+    VmaVirtualBlockCreateFlags flags;
+
+    /** \brief Custom CPU memory allocation callbacks. Optional.
+
+    Optional, can be null. When specified, they will be used for all CPU-side memory allocations.
+    */
+    const VkAllocationCallbacks* VMA_NULLABLE pAllocationCallbacks;
+} VmaVirtualBlockCreateInfo;
+
+/// Parameters of created virtual allocation to be passed to vmaVirtualAllocate().
+typedef struct VmaVirtualAllocationCreateInfo
+{
+    /** \brief Size of the allocation.
+
+    Cannot be zero.
+    */
+    VkDeviceSize size;
+    /** \brief Required alignment of the allocation. Optional.
+
+    Must be power of two. Special value 0 has the same meaning as 1 - means no special alignment is required, so allocation can start at any offset.
+    */
+    VkDeviceSize alignment;
+    /** \brief Use combination of #VmaVirtualAllocationCreateFlagBits.
+    */
+    VmaVirtualAllocationCreateFlags flags;
+    /** \brief Custom pointer to be associated with the allocation. Optional.
+
+    It can be any value and can be used for user-defined purposes. It can be fetched or changed later.
+    */
+    void* VMA_NULLABLE pUserData;
+} VmaVirtualAllocationCreateInfo;
+
+/// Parameters of an existing virtual allocation, returned by vmaGetVirtualAllocationInfo().
+typedef struct VmaVirtualAllocationInfo
+{
+    /** \brief Offset of the allocation.
+     
+    Offset at which the allocation was made.
+    */
+    VkDeviceSize offset;
+    /** \brief Size of the allocation.
+
+    Same value as passed in VmaVirtualAllocationCreateInfo::size.
+    */
+    VkDeviceSize size;
+    /** \brief Custom pointer associated with the allocation.
+
+    Same value as passed in VmaVirtualAllocationCreateInfo::pUserData or to vmaSetVirtualAllocationUserData().
+    */
+    void* VMA_NULLABLE pUserData;
+} VmaVirtualAllocationInfo;
+
+/** @} */
+
+#endif // _VMA_DATA_TYPES_DECLARATIONS
+
+#ifndef _VMA_FUNCTION_HEADERS
+
+/**
+\addtogroup group_init
+@{
+*/
+
+/// Creates #VmaAllocator object.
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
+    const VmaAllocatorCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocator VMA_NULLABLE* VMA_NOT_NULL pAllocator);
+
+/// Destroys allocator object.
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
+    VmaAllocator VMA_NULLABLE allocator);
+
+/** \brief Returns information about existing #VmaAllocator object - handle to Vulkan device etc.
+
+It might be useful if you want to keep just the #VmaAllocator handle and fetch other required handles to
+`VkPhysicalDevice`, `VkDevice` etc. every time using this function.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocatorInfo(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocatorInfo* VMA_NOT_NULL pAllocatorInfo);
+
+/**
+PhysicalDeviceProperties are fetched from physicalDevice by the allocator.
+You can access it here, without fetching it again on your own.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkPhysicalDeviceProperties* VMA_NULLABLE* VMA_NOT_NULL ppPhysicalDeviceProperties);
+
+/**
+PhysicalDeviceMemoryProperties are fetched from physicalDevice by the allocator.
+You can access it here, without fetching it again on your own.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkPhysicalDeviceMemoryProperties* VMA_NULLABLE* VMA_NOT_NULL ppPhysicalDeviceMemoryProperties);
+
+/**
+\brief Given Memory Type Index, returns Property Flags of this memory type.
+
+This is just a convenience function. Same information can be obtained using
+vmaGetMemoryProperties().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t memoryTypeIndex,
+    VkMemoryPropertyFlags* VMA_NOT_NULL pFlags);
+
+/** \brief Sets index of the current frame.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t frameIndex);
+
+/** @} */
+
+/**
+\addtogroup group_stats
+@{
+*/
+
+/** \brief Retrieves statistics from current state of the Allocator.
+
+This function is called "calculate" not "get" because it has to traverse all
+internal data structures, so it may be quite slow. Use it for debugging purposes.
+For faster but more brief statistics suitable to be called every frame or every allocation,
+use vmaGetHeapBudgets().
+
+Note that when using allocator from multiple threads, returned information may immediately
+become outdated.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStatistics(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaTotalStatistics* VMA_NOT_NULL pStats);
+
+/** \brief Retrieves information about current memory usage and budget for all memory heaps.
+
+\param allocator
+\param[out] pBudgets Must point to array with number of elements at least equal to number of memory heaps in physical device used.
+
+This function is called "get" not "calculate" because it is very fast, suitable to be called
+every frame or every allocation. For more detailed statistics use vmaCalculateStatistics().
+
+Note that when using allocator from multiple threads, returned information may immediately
+become outdated.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetHeapBudgets(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaBudget* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL("VkPhysicalDeviceMemoryProperties::memoryHeapCount") pBudgets);
+
+/** @} */
+
+/**
+\addtogroup group_alloc
+@{
+*/
+
+/**
+\brief Helps to find memoryTypeIndex, given memoryTypeBits and VmaAllocationCreateInfo.
+
+This algorithm tries to find a memory type that:
+
+- Is allowed by memoryTypeBits.
+- Contains all the flags from pAllocationCreateInfo->requiredFlags.
+- Matches intended usage.
+- Has as many flags from pAllocationCreateInfo->preferredFlags as possible.
+
+\return Returns VK_ERROR_FEATURE_NOT_PRESENT if not found. Receiving such result
+from this function or any other allocating function probably means that your
+device doesn't support any memory type with requested features for the specific
+type of resource you want to use it for. Please check parameters of your
+resource, like image layout (OPTIMAL versus LINEAR) or mip level count.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t memoryTypeBits,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);
+
+/**
+\brief Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.
+
+It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex.
+It internally creates a temporary, dummy buffer that never has memory bound.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);
+
+/**
+\brief Helps to find memoryTypeIndex, given VkImageCreateInfo and VmaAllocationCreateInfo.
+
+It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex.
+It internally creates a temporary, dummy image that never has memory bound.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    uint32_t* VMA_NOT_NULL pMemoryTypeIndex);
+
+/** \brief Allocates Vulkan device memory and creates #VmaPool object.
+
+\param allocator Allocator object.
+\param pCreateInfo Parameters of pool to create.
+\param[out] pPool Handle to created pool.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VmaPoolCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaPool VMA_NULLABLE* VMA_NOT_NULL pPool);
+
+/** \brief Destroys #VmaPool object and frees Vulkan device memory.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NULLABLE pool);
+
+/** @} */
+
+/**
+\addtogroup group_stats
+@{
+*/
+
+/** \brief Retrieves statistics of existing #VmaPool object.
+
+\param allocator Allocator object.
+\param pool Pool object.
+\param[out] pPoolStats Statistics of specified pool.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStatistics(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    VmaStatistics* VMA_NOT_NULL pPoolStats);
+
+/** \brief Retrieves detailed statistics of existing #VmaPool object.
+
+\param allocator Allocator object.
+\param pool Pool object.
+\param[out] pPoolStats Statistics of specified pool.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculatePoolStatistics(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    VmaDetailedStatistics* VMA_NOT_NULL pPoolStats);
+
+/** @} */
+
+/**
+\addtogroup group_alloc
+@{
+*/
+
+/** \brief Checks magic number in margins around all allocations in given memory pool in search for corruptions.
+
+Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,
+`VMA_DEBUG_MARGIN` is defined to nonzero and the pool is created in memory type that is
+`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection).
+
+Possible return values:
+
+- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for specified pool.
+- `VK_SUCCESS` - corruption detection has been performed and succeeded.
+- `VK_ERROR_UNKNOWN` - corruption detection has been performed and found memory corruptions around one of the allocations.
+  `VMA_ASSERT` is also fired in that case.
+- Other value: Error returned by Vulkan, e.g. memory mapping failure.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool);
+
+/** \brief Retrieves name of a custom pool.
+
+After the call `ppName` is either null or points to an internally-owned null-terminated string
+containing name of the pool that was previously set. The pointer becomes invalid when the pool is
+destroyed or its name is changed using vmaSetPoolName().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    const char* VMA_NULLABLE* VMA_NOT_NULL ppName);
+
+/** \brief Sets name of a custom pool.
+
+`pName` can be either null or pointer to a null-terminated string with new name for the pool.
+Function makes internal copy of the string, so it can be changed or freed immediately after this call.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaPool VMA_NOT_NULL pool,
+    const char* VMA_NULLABLE pName);
+
+/** \brief General purpose memory allocation.
+
+\param allocator
+\param pVkMemoryRequirements
+\param pCreateInfo
+\param[out] pAllocation Handle to allocated memory.
+\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
+
+You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().
+
+It is recommended to use vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(),
+vmaCreateBuffer(), vmaCreateImage() instead whenever possible.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkMemoryRequirements* VMA_NOT_NULL pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief General purpose memory allocation for multiple allocation objects at once.
+
+\param allocator Allocator object.
+\param pVkMemoryRequirements Memory requirements for each allocation.
+\param pCreateInfo Creation parameters for each allocation.
+\param allocationCount Number of allocations to make.
+\param[out] pAllocations Pointer to array that will be filled with handles to created allocations.
+\param[out] pAllocationInfo Optional. Pointer to array that will be filled with parameters of created allocations.
+
+You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().
+
+Word "pages" is just a suggestion to use this function to allocate pieces of memory needed for sparse binding.
+It is just a general purpose allocation function able to make multiple allocations at once.
+It may be internally optimized to be more efficient than calling vmaAllocateMemory() `allocationCount` times.
+
+All allocations are made using same parameters. All of them are created out of the same memory pool and type.
+If any allocation fails, all allocations already made within this function call are also freed, so that when
+returned result is not `VK_SUCCESS`, `pAllocation` array is always entirely filled with `VK_NULL_HANDLE`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkMemoryRequirements* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pCreateInfo,
+    size_t allocationCount,
+    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations,
+    VmaAllocationInfo* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocationInfo);
+
+/** \brief Allocates memory suitable for given `VkBuffer`.
+
+\param allocator
+\param buffer
+\param pCreateInfo
+\param[out] pAllocation Handle to allocated memory.
+\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
+
+It only creates #VmaAllocation. To bind the memory to the buffer, use vmaBindBufferMemory().
+
+This is a special-purpose function. In most cases you should use vmaCreateBuffer().
+
+You must free the allocation using vmaFreeMemory() when no longer needed.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief Allocates memory suitable for given `VkImage`.
+
+\param allocator
+\param image
+\param pCreateInfo
+\param[out] pAllocation Handle to allocated memory.
+\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
+
+It only creates #VmaAllocation. To bind the memory to the buffer, use vmaBindImageMemory().
+
+This is a special-purpose function. In most cases you should use vmaCreateImage().
+
+You must free the allocation using vmaFreeMemory() when no longer needed.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().
+
+Passing `VK_NULL_HANDLE` as `allocation` is valid. Such function call is just skipped.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VmaAllocation VMA_NULLABLE allocation);
+
+/** \brief Frees memory and destroys multiple allocations.
+
+Word "pages" is just a suggestion to use this function to free pieces of memory used for sparse binding.
+It is just a general purpose function to free memory and destroy allocations made using e.g. vmaAllocateMemory(),
+vmaAllocateMemoryPages() and other functions.
+It may be internally optimized to be more efficient than calling vmaFreeMemory() `allocationCount` times.
+
+Allocations in `pAllocations` array can come from any memory pools and types.
+Passing `VK_NULL_HANDLE` as elements of `pAllocations` array is valid. Such entries are just skipped.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
+    VmaAllocator VMA_NOT_NULL allocator,
+    size_t allocationCount,
+    const VmaAllocation VMA_NULLABLE* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations);
+
+/** \brief Returns current information about specified allocation.
+
+Current paramteres of given allocation are returned in `pAllocationInfo`.
+
+Although this function doesn't lock any mutex, so it should be quite efficient,
+you should avoid calling it too often.
+You can retrieve same VmaAllocationInfo structure while creating your resource, from function
+vmaCreateBuffer(), vmaCreateImage(). You can remember it if you are sure parameters don't change
+(e.g. due to defragmentation).
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VmaAllocationInfo* VMA_NOT_NULL pAllocationInfo);
+
+/** \brief Sets pUserData in given allocation to new value.
+
+The value of pointer `pUserData` is copied to allocation's `pUserData`.
+It is opaque, so you can use it however you want - e.g.
+as a pointer, ordinal number or some handle to you own data.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    void* VMA_NULLABLE pUserData);
+
+/** \brief Sets pName in given allocation to new value.
+
+`pName` must be either null, or pointer to a null-terminated string. The function
+makes local copy of the string and sets it as allocation's `pName`. String
+passed as pName doesn't need to be valid for whole lifetime of the allocation -
+you can free it after this call. String previously pointed by allocation's
+`pName` is freed from memory.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationName(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    const char* VMA_NULLABLE pName);
+
+/**
+\brief Given an allocation, returns Property Flags of its memory type.
+
+This is just a convenience function. Same information can be obtained using
+vmaGetAllocationInfo() + vmaGetMemoryProperties().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationMemoryProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkMemoryPropertyFlags* VMA_NOT_NULL pFlags);
+
+/** \brief Maps memory represented by given allocation and returns pointer to it.
+
+Maps memory represented by given allocation to make it accessible to CPU code.
+When succeeded, `*ppData` contains pointer to first byte of this memory.
+
+\warning
+If the allocation is part of a bigger `VkDeviceMemory` block, returned pointer is
+correctly offsetted to the beginning of region assigned to this particular allocation.
+Unlike the result of `vkMapMemory`, it points to the allocation, not to the beginning of the whole block.
+You should not add VmaAllocationInfo::offset to it!
+
+Mapping is internally reference-counted and synchronized, so despite raw Vulkan
+function `vkMapMemory()` cannot be used to map same block of `VkDeviceMemory`
+multiple times simultaneously, it is safe to call this function on allocations
+assigned to the same memory block. Actual Vulkan memory will be mapped on first
+mapping and unmapped on last unmapping.
+
+If the function succeeded, you must call vmaUnmapMemory() to unmap the
+allocation when mapping is no longer needed or before freeing the allocation, at
+the latest.
+
+It also safe to call this function multiple times on the same allocation. You
+must call vmaUnmapMemory() same number of times as you called vmaMapMemory().
+
+It is also safe to call this function on allocation created with
+#VMA_ALLOCATION_CREATE_MAPPED_BIT flag. Its memory stays mapped all the time.
+You must still call vmaUnmapMemory() same number of times as you called
+vmaMapMemory(). You must not call vmaUnmapMemory() additional time to free the
+"0-th" mapping made automatically due to #VMA_ALLOCATION_CREATE_MAPPED_BIT flag.
+
+This function fails when used on allocation made in memory type that is not
+`HOST_VISIBLE`.
+
+This function doesn't automatically flush or invalidate caches.
+If the allocation is made from a memory types that is not `HOST_COHERENT`,
+you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    void* VMA_NULLABLE* VMA_NOT_NULL ppData);
+
+/** \brief Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
+
+For details, see description of vmaMapMemory().
+
+This function doesn't automatically flush or invalidate caches.
+If the allocation is made from a memory types that is not `HOST_COHERENT`,
+you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation);
+
+/** \brief Flushes memory of given allocation.
+
+Calls `vkFlushMappedMemoryRanges()` for memory associated with given range of given allocation.
+It needs to be called after writing to a mapped memory for memory types that are not `HOST_COHERENT`.
+Unmap operation doesn't do that automatically.
+
+- `offset` must be relative to the beginning of allocation.
+- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation.
+- `offset` and `size` don't have to be aligned.
+  They are internally rounded down/up to multiply of `nonCoherentAtomSize`.
+- If `size` is 0, this call is ignored.
+- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,
+  this call is ignored.
+
+Warning! `offset` and `size` are relative to the contents of given `allocation`.
+If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively.
+Do not pass allocation's offset as `offset`!!!
+
+This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
+called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize offset,
+    VkDeviceSize size);
+
+/** \brief Invalidates memory of given allocation.
+
+Calls `vkInvalidateMappedMemoryRanges()` for memory associated with given range of given allocation.
+It needs to be called before reading from a mapped memory for memory types that are not `HOST_COHERENT`.
+Map operation doesn't do that automatically.
+
+- `offset` must be relative to the beginning of allocation.
+- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation.
+- `offset` and `size` don't have to be aligned.
+  They are internally rounded down/up to multiply of `nonCoherentAtomSize`.
+- If `size` is 0, this call is ignored.
+- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,
+  this call is ignored.
+
+Warning! `offset` and `size` are relative to the contents of given `allocation`.
+If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively.
+Do not pass allocation's offset as `offset`!!!
+
+This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if
+it is called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize offset,
+    VkDeviceSize size);
+
+/** \brief Flushes memory of given set of allocations.
+
+Calls `vkFlushMappedMemoryRanges()` for memory associated with given ranges of given allocations.
+For more information, see documentation of vmaFlushAllocation().
+
+\param allocator
+\param allocationCount
+\param allocations
+\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
+\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
+
+This function returns the `VkResult` from `vkFlushMappedMemoryRanges` if it is
+called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t allocationCount,
+    const VmaAllocation VMA_NOT_NULL* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) allocations,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) offsets,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) sizes);
+
+/** \brief Invalidates memory of given set of allocations.
+
+Calls `vkInvalidateMappedMemoryRanges()` for memory associated with given ranges of given allocations.
+For more information, see documentation of vmaInvalidateAllocation().
+
+\param allocator
+\param allocationCount
+\param allocations
+\param offsets If not null, it must point to an array of offsets of regions to flush, relative to the beginning of respective allocations. Null means all ofsets are zero.
+\param sizes If not null, it must point to an array of sizes of regions to flush in respective allocations. Null means `VK_WHOLE_SIZE` for all allocations.
+
+This function returns the `VkResult` from `vkInvalidateMappedMemoryRanges` if it is
+called, otherwise `VK_SUCCESS`.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t allocationCount,
+    const VmaAllocation VMA_NOT_NULL* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) allocations,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) offsets,
+    const VkDeviceSize* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) sizes);
+
+/** \brief Checks magic number in margins around all allocations in given memory types (in both default and custom pools) in search for corruptions.
+
+\param allocator
+\param memoryTypeBits Bit mask, where each bit set means that a memory type with that index should be checked.
+
+Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,
+`VMA_DEBUG_MARGIN` is defined to nonzero and only for memory types that are
+`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection).
+
+Possible return values:
+
+- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for any of specified memory types.
+- `VK_SUCCESS` - corruption detection has been performed and succeeded.
+- `VK_ERROR_UNKNOWN` - corruption detection has been performed and found memory corruptions around one of the allocations.
+  `VMA_ASSERT` is also fired in that case.
+- Other value: Error returned by Vulkan, e.g. memory mapping failure.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(
+    VmaAllocator VMA_NOT_NULL allocator,
+    uint32_t memoryTypeBits);
+
+/** \brief Begins defragmentation process.
+
+\param allocator Allocator object.
+\param pInfo Structure filled with parameters of defragmentation.
+\param[out] pContext Context object that must be passed to vmaEndDefragmentation() to finish defragmentation.
+\returns
+- `VK_SUCCESS` if defragmentation can begin.
+- `VK_ERROR_FEATURE_NOT_PRESENT` if defragmentation is not supported.
+
+For more information about defragmentation, see documentation chapter:
+[Defragmentation](@ref defragmentation).
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VmaDefragmentationInfo* VMA_NOT_NULL pInfo,
+    VmaDefragmentationContext VMA_NULLABLE* VMA_NOT_NULL pContext);
+
+/** \brief Ends defragmentation process.
+
+\param allocator Allocator object.
+\param context Context object that has been created by vmaBeginDefragmentation().
+\param[out] pStats Optional stats for the defragmentation. Can be null.
+
+Use this function to finish defragmentation started by vmaBeginDefragmentation().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaEndDefragmentation(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NOT_NULL context,
+    VmaDefragmentationStats* VMA_NULLABLE pStats);
+
+/** \brief Starts single defragmentation pass.
+
+\param allocator Allocator object.
+\param context Context object that has been created by vmaBeginDefragmentation().
+\param[out] pPassInfo Computed informations for current pass.
+\returns
+- `VK_SUCCESS` if no more moves are possible. Then you can omit call to vmaEndDefragmentationPass() and simply end whole defragmentation.
+- `VK_INCOMPLETE` if there are pending moves returned in `pPassInfo`. You need to perform them, call vmaEndDefragmentationPass(),
+  and then preferably try another pass with vmaBeginDefragmentationPass().
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NOT_NULL context,
+    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo);
+
+/** \brief Ends single defragmentation pass.
+
+\param allocator Allocator object.
+\param context Context object that has been created by vmaBeginDefragmentation().
+\param pPassInfo Computed informations for current pass filled by vmaBeginDefragmentationPass() and possibly modified by you.
+
+Returns `VK_SUCCESS` if no more moves are possible or `VK_INCOMPLETE` if more defragmentations are possible.
+
+Ends incremental defragmentation pass and commits all defragmentation moves from `pPassInfo`.
+After this call:
+
+- Allocations at `pPassInfo[i].srcAllocation` that had `pPassInfo[i].operation ==` #VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY
+  (which is the default) will be pointing to the new destination place.
+- Allocation at `pPassInfo[i].srcAllocation` that had `pPassInfo[i].operation ==` #VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY
+  will be freed.
+
+If no more moves are possible you can end whole defragmentation.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NOT_NULL context,
+    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo);
+
+/** \brief Binds buffer to allocation.
+
+Binds specified buffer to region of memory represented by specified allocation.
+Gets `VkDeviceMemory` handle and offset from the allocation.
+If you want to create a buffer, allocate memory for it and bind them together separately,
+you should use this function for binding instead of standard `vkBindBufferMemory()`,
+because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple
+allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously
+(which is illegal in Vulkan).
+
+It is recommended to use function vmaCreateBuffer() instead of this one.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer);
+
+/** \brief Binds buffer to allocation with additional parameters.
+
+\param allocator
+\param allocation
+\param allocationLocalOffset Additional offset to be added while binding, relative to the beginning of the `allocation`. Normally it should be 0.
+\param buffer
+\param pNext A chain of structures to be attached to `VkBindBufferMemoryInfoKHR` structure used internally. Normally it should be null.
+
+This function is similar to vmaBindBufferMemory(), but it provides additional parameters.
+
+If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag
+or with VmaAllocatorCreateInfo::vulkanApiVersion `>= VK_API_VERSION_1_1`. Otherwise the call fails.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer VMA_NOT_NULL_NON_DISPATCHABLE buffer,
+    const void* VMA_NULLABLE pNext);
+
+/** \brief Binds image to allocation.
+
+Binds specified image to region of memory represented by specified allocation.
+Gets `VkDeviceMemory` handle and offset from the allocation.
+If you want to create an image, allocate memory for it and bind them together separately,
+you should use this function for binding instead of standard `vkBindImageMemory()`,
+because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple
+allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously
+(which is illegal in Vulkan).
+
+It is recommended to use function vmaCreateImage() instead of this one.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image);
+
+/** \brief Binds image to allocation with additional parameters.
+
+\param allocator
+\param allocation
+\param allocationLocalOffset Additional offset to be added while binding, relative to the beginning of the `allocation`. Normally it should be 0.
+\param image
+\param pNext A chain of structures to be attached to `VkBindImageMemoryInfoKHR` structure used internally. Normally it should be null.
+
+This function is similar to vmaBindImageMemory(), but it provides additional parameters.
+
+If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag
+or with VmaAllocatorCreateInfo::vulkanApiVersion `>= VK_API_VERSION_1_1`. Otherwise the call fails.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage VMA_NOT_NULL_NON_DISPATCHABLE image,
+    const void* VMA_NULLABLE pNext);
+
+/** \brief Creates a new `VkBuffer`, allocates and binds memory for it.
+
+\param allocator
+\param pBufferCreateInfo
+\param pAllocationCreateInfo
+\param[out] pBuffer Buffer that was created.
+\param[out] pAllocation Allocation that was created.
+\param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
+
+This function automatically:
+
+-# Creates buffer.
+-# Allocates appropriate memory for it.
+-# Binds the buffer with the memory.
+
+If any of these operations fail, buffer and allocation are not created,
+returned value is negative error code, `*pBuffer` and `*pAllocation` are null.
+
+If the function succeeded, you must destroy both buffer and allocation when you
+no longer need them using either convenience function vmaDestroyBuffer() or
+separately, using `vkDestroyBuffer()` and vmaFreeMemory().
+
+If #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag was used,
+VK_KHR_dedicated_allocation extension is used internally to query driver whether
+it requires or prefers the new buffer to have dedicated allocation. If yes,
+and if dedicated allocation is possible
+(#VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT is not used), it creates dedicated
+allocation for this buffer, just like when using
+#VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+
+\note This function creates a new `VkBuffer`. Sub-allocation of parts of one large buffer,
+although recommended as a good practice, is out of scope of this library and could be implemented
+by the user as a higher-level logic on top of VMA.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer,
+    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief Creates a buffer with additional minimum alignment.
+
+Similar to vmaCreateBuffer() but provides additional parameter `minAlignment` which allows to specify custom,
+minimum alignment to be used when placing the buffer inside a larger memory block, which may be needed e.g.
+for interop with OpenGL.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    VkDeviceSize minAlignment,
+    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer,
+    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/** \brief Creates a new `VkBuffer`, binds already created memory for it.
+
+\param allocator
+\param allocation Allocation that provides memory to be used for binding new buffer to it.
+\param pBufferCreateInfo
+\param[out] pBuffer Buffer that was created.
+
+This function automatically:
+
+-# Creates buffer.
+-# Binds the buffer with the supplied memory.
+
+If any of these operations fail, buffer is not created,
+returned value is negative error code and `*pBuffer` is null.
+
+If the function succeeded, you must destroy the buffer when you
+no longer need it using `vkDestroyBuffer()`. If you want to also destroy the corresponding
+allocation you can use convenience function vmaDestroyBuffer().
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
+    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer);
+
+/** \brief Destroys Vulkan buffer and frees allocated memory.
+
+This is just a convenience function equivalent to:
+
+\code
+vkDestroyBuffer(device, buffer, allocationCallbacks);
+vmaFreeMemory(allocator, allocation);
+\endcode
+
+It it safe to pass null as buffer and/or allocation.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE buffer,
+    VmaAllocation VMA_NULLABLE allocation);
+
+/// Function similar to vmaCreateBuffer().
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
+    const VmaAllocationCreateInfo* VMA_NOT_NULL pAllocationCreateInfo,
+    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage,
+    VmaAllocation VMA_NULLABLE* VMA_NOT_NULL pAllocation,
+    VmaAllocationInfo* VMA_NULLABLE pAllocationInfo);
+
+/// Function similar to vmaCreateAliasingBuffer().
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
+    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage);
+
+/** \brief Destroys Vulkan image and frees allocated memory.
+
+This is just a convenience function equivalent to:
+
+\code
+vkDestroyImage(device, image, allocationCallbacks);
+vmaFreeMemory(allocator, allocation);
+\endcode
+
+It it safe to pass null as image and/or allocation.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkImage VMA_NULLABLE_NON_DISPATCHABLE image,
+    VmaAllocation VMA_NULLABLE allocation);
+
+/** @} */
+
+/**
+\addtogroup group_virtual
+@{
+*/
+
+/** \brief Creates new #VmaVirtualBlock object.
+
+\param pCreateInfo Parameters for creation.
+\param[out] pVirtualBlock Returned virtual block object or `VMA_NULL` if creation failed.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateVirtualBlock(
+    const VmaVirtualBlockCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaVirtualBlock VMA_NULLABLE* VMA_NOT_NULL pVirtualBlock);
+
+/** \brief Destroys #VmaVirtualBlock object.
+
+Please note that you should consciously handle virtual allocations that could remain unfreed in the block.
+You should either free them individually using vmaVirtualFree() or call vmaClearVirtualBlock()
+if you are sure this is what you want. If you do neither, an assert is called.
+
+If you keep pointers to some additional metadata associated with your virtual allocations in their `pUserData`,
+don't forget to free them.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyVirtualBlock(
+    VmaVirtualBlock VMA_NULLABLE virtualBlock);
+
+/** \brief Returns true of the #VmaVirtualBlock is empty - contains 0 virtual allocations and has all its space available for new allocations.
+*/
+VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaIsVirtualBlockEmpty(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock);
+
+/** \brief Returns information about a specific virtual allocation within a virtual block, like its size and `pUserData` pointer.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualAllocationInfo(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation, VmaVirtualAllocationInfo* VMA_NOT_NULL pVirtualAllocInfo);
+
+/** \brief Allocates new virtual allocation inside given #VmaVirtualBlock.
+
+If the allocation fails due to not enough free space available, `VK_ERROR_OUT_OF_DEVICE_MEMORY` is returned
+(despite the function doesn't ever allocate actual GPU memory).
+`pAllocation` is then set to `VK_NULL_HANDLE` and `pOffset`, if not null, it set to `UINT64_MAX`.
+
+\param virtualBlock Virtual block
+\param pCreateInfo Parameters for the allocation
+\param[out] pAllocation Returned handle of the new allocation
+\param[out] pOffset Returned offset of the new allocation. Optional, can be null.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaVirtualAllocate(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    const VmaVirtualAllocationCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pAllocation,
+    VkDeviceSize* VMA_NULLABLE pOffset);
+
+/** \brief Frees virtual allocation inside given #VmaVirtualBlock.
+
+It is correct to call this function with `allocation == VK_NULL_HANDLE` - it does nothing.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaVirtualFree(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE allocation);
+
+/** \brief Frees all virtual allocations inside given #VmaVirtualBlock.
+
+You must either call this function or free each virtual allocation individually with vmaVirtualFree()
+before destroying a virtual block. Otherwise, an assert is called.
+
+If you keep pointer to some additional metadata associated with your virtual allocation in its `pUserData`,
+don't forget to free it as well.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaClearVirtualBlock(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock);
+
+/** \brief Changes custom pointer associated with given virtual allocation.
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaSetVirtualAllocationUserData(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation,
+    void* VMA_NULLABLE pUserData);
+
+/** \brief Calculates and returns statistics about virtual allocations and memory usage in given #VmaVirtualBlock.
+
+This function is fast to call. For more detailed statistics, see vmaCalculateVirtualBlockStatistics().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualBlockStatistics(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaStatistics* VMA_NOT_NULL pStats);
+
+/** \brief Calculates and returns detailed statistics about virtual allocations and memory usage in given #VmaVirtualBlock.
+
+This function is slow to call. Use for debugging purposes.
+For less detailed statistics, see vmaGetVirtualBlockStatistics().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateVirtualBlockStatistics(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaDetailedStatistics* VMA_NOT_NULL pStats);
+
+/** @} */
+
+#if VMA_STATS_STRING_ENABLED
+/**
+\addtogroup group_stats
+@{
+*/
+
+/** \brief Builds and returns a null-terminated string in JSON format with information about given #VmaVirtualBlock.
+\param virtualBlock Virtual block.
+\param[out] ppStatsString Returned string.
+\param detailedMap Pass `VK_FALSE` to only obtain statistics as returned by vmaCalculateVirtualBlockStatistics(). Pass `VK_TRUE` to also obtain full list of allocations and free spaces.
+
+Returned string must be freed using vmaFreeVirtualBlockStatsString().
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaBuildVirtualBlockStatsString(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    char* VMA_NULLABLE* VMA_NOT_NULL ppStatsString,
+    VkBool32 detailedMap);
+
+/// Frees a string returned by vmaBuildVirtualBlockStatsString().
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeVirtualBlockStatsString(
+    VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    char* VMA_NULLABLE pStatsString);
+
+/** \brief Builds and returns statistics as a null-terminated string in JSON format.
+\param allocator
+\param[out] ppStatsString Must be freed using vmaFreeStatsString() function.
+\param detailedMap
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
+    VmaAllocator VMA_NOT_NULL allocator,
+    char* VMA_NULLABLE* VMA_NOT_NULL ppStatsString,
+    VkBool32 detailedMap);
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
+    VmaAllocator VMA_NOT_NULL allocator,
+    char* VMA_NULLABLE pStatsString);
+
+/** @} */
+
+#endif // VMA_STATS_STRING_ENABLED
+
+#endif // _VMA_FUNCTION_HEADERS
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// 
+//    IMPLEMENTATION
+// 
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// For Visual Studio IntelliSense.
+#if defined(__cplusplus) && defined(__INTELLISENSE__)
+#define VMA_IMPLEMENTATION
+#endif
+
+#ifdef VMA_IMPLEMENTATION
+#undef VMA_IMPLEMENTATION
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <utility>
+#include <type_traits>
+
+#ifdef _MSC_VER
+    #include <intrin.h> // For functions like __popcnt, _BitScanForward etc.
+#endif
+#if __cplusplus >= 202002L || _MSVC_LANG >= 202002L // C++20
+    #include <bit> // For std::popcount
+#endif
+
+/*******************************************************************************
+CONFIGURATION SECTION
+
+Define some of these macros before each #include of this header or change them
+here if you need other then default behavior depending on your environment.
+*/
+#ifndef _VMA_CONFIGURATION
+
+/*
+Define this macro to 1 to make the library fetch pointers to Vulkan functions
+internally, like:
+
+    vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
+*/
+#if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
+    #define VMA_STATIC_VULKAN_FUNCTIONS 1
+#endif
+
+/*
+Define this macro to 1 to make the library fetch pointers to Vulkan functions
+internally, like:
+
+    vulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkGetDeviceProcAddr(device, "vkAllocateMemory");
+
+To use this feature in new versions of VMA you now have to pass
+VmaVulkanFunctions::vkGetInstanceProcAddr and vkGetDeviceProcAddr as
+VmaAllocatorCreateInfo::pVulkanFunctions. Other members can be null.
+*/
+#if !defined(VMA_DYNAMIC_VULKAN_FUNCTIONS)
+    #define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
+#endif
+
+#ifndef VMA_USE_STL_SHARED_MUTEX
+    // Compiler conforms to C++17.
+    #if __cplusplus >= 201703L
+        #define VMA_USE_STL_SHARED_MUTEX 1
+    // Visual studio defines __cplusplus properly only when passed additional parameter: /Zc:__cplusplus
+    // Otherwise it is always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.
+    #elif defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && __cplusplus == 199711L && _MSVC_LANG >= 201703L
+        #define VMA_USE_STL_SHARED_MUTEX 1
+    #else
+        #define VMA_USE_STL_SHARED_MUTEX 0
+    #endif
+#endif
+
+/*
+Define this macro to include custom header files without having to edit this file directly, e.g.:
+
+    // Inside of "my_vma_configuration_user_includes.h":
+
+    #include "my_custom_assert.h" // for MY_CUSTOM_ASSERT
+    #include "my_custom_min.h" // for my_custom_min
+    #include <algorithm>
+    #include <mutex>
+
+    // Inside a different file, which includes "vk_mem_alloc.h":
+
+    #define VMA_CONFIGURATION_USER_INCLUDES_H "my_vma_configuration_user_includes.h"
+    #define VMA_ASSERT(expr) MY_CUSTOM_ASSERT(expr)
+    #define VMA_MIN(v1, v2)  (my_custom_min(v1, v2))
+    #include "vk_mem_alloc.h"
+    ...
+
+The following headers are used in this CONFIGURATION section only, so feel free to
+remove them if not needed.
+*/
+#if !defined(VMA_CONFIGURATION_USER_INCLUDES_H)
+    #include <cassert> // for assert
+    #include <algorithm> // for min, max
+    #include <mutex>
+#else
+    #include VMA_CONFIGURATION_USER_INCLUDES_H
+#endif
+
+#ifndef VMA_NULL
+   // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
+   #define VMA_NULL   nullptr
+#endif
+
+#if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
+#include <cstdlib>
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+    // alignment must be >= sizeof(void*)
+    if(alignment < sizeof(void*))
+    {
+        alignment = sizeof(void*);
+    }
+
+    return memalign(alignment, size);
+}
+#elif defined(__APPLE__) || defined(__ANDROID__) || (defined(__linux__) && defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC))
+#include <cstdlib>
+
+#if defined(__APPLE__)
+#include <AvailabilityMacros.h>
+#endif
+
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+    // Unfortunately, aligned_alloc causes VMA to crash due to it returning null pointers. (At least under 11.4)
+    // Therefore, for now disable this specific exception until a proper solution is found.
+    //#if defined(__APPLE__) && (defined(MAC_OS_X_VERSION_10_16) || defined(__IPHONE_14_0))
+    //#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_16 || __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0
+    //    // For C++14, usr/include/malloc/_malloc.h declares aligned_alloc()) only
+    //    // with the MacOSX11.0 SDK in Xcode 12 (which is what adds
+    //    // MAC_OS_X_VERSION_10_16), even though the function is marked
+    //    // availabe for 10.15. That is why the preprocessor checks for 10.16 but
+    //    // the __builtin_available checks for 10.15.
+    //    // People who use C++17 could call aligned_alloc with the 10.15 SDK already.
+    //    if (__builtin_available(macOS 10.15, iOS 13, *))
+    //        return aligned_alloc(alignment, size);
+    //#endif
+    //#endif
+
+    // alignment must be >= sizeof(void*)
+    if(alignment < sizeof(void*))
+    {
+        alignment = sizeof(void*);
+    }
+
+    void *pointer;
+    if(posix_memalign(&pointer, alignment, size) == 0)
+        return pointer;
+    return VMA_NULL;
+}
+#elif defined(_WIN32)
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+    return _aligned_malloc(size, alignment);
+}
+#else
+static void* vma_aligned_alloc(size_t alignment, size_t size)
+{
+    return aligned_alloc(alignment, size);
+}
+#endif
+
+#if defined(_WIN32)
+static void vma_aligned_free(void* ptr)
+{
+    _aligned_free(ptr);
+}
+#else
+static void vma_aligned_free(void* VMA_NULLABLE ptr)
+{
+    free(ptr);
+}
+#endif
+
+// If your compiler is not compatible with C++11 and definition of
+// aligned_alloc() function is missing, uncommeting following line may help:
+
+//#include <malloc.h>
+
+// Normal assert to check for programmer's errors, especially in Debug configuration.
+#ifndef VMA_ASSERT
+   #ifdef NDEBUG
+       #define VMA_ASSERT(expr)
+   #else
+       #define VMA_ASSERT(expr)         assert(expr)
+   #endif
+#endif
+
+// Assert that will be called very often, like inside data structures e.g. operator[].
+// Making it non-empty can make program slow.
+#ifndef VMA_HEAVY_ASSERT
+   #ifdef NDEBUG
+       #define VMA_HEAVY_ASSERT(expr)
+   #else
+       #define VMA_HEAVY_ASSERT(expr)   //VMA_ASSERT(expr)
+   #endif
+#endif
+
+#ifndef VMA_ALIGN_OF
+   #define VMA_ALIGN_OF(type)       (__alignof(type))
+#endif
+
+#ifndef VMA_SYSTEM_ALIGNED_MALLOC
+   #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) vma_aligned_alloc((alignment), (size))
+#endif
+
+#ifndef VMA_SYSTEM_ALIGNED_FREE
+   // VMA_SYSTEM_FREE is the old name, but might have been defined by the user
+   #if defined(VMA_SYSTEM_FREE)
+      #define VMA_SYSTEM_ALIGNED_FREE(ptr)     VMA_SYSTEM_FREE(ptr)
+   #else
+      #define VMA_SYSTEM_ALIGNED_FREE(ptr)     vma_aligned_free(ptr)
+    #endif
+#endif
+
+#ifndef VMA_COUNT_BITS_SET
+    // Returns number of bits set to 1 in (v)
+    #define VMA_COUNT_BITS_SET(v) VmaCountBitsSet(v)
+#endif
+
+#ifndef VMA_BITSCAN_LSB
+    // Scans integer for index of first nonzero value from the Least Significant Bit (LSB). If mask is 0 then returns UINT8_MAX
+    #define VMA_BITSCAN_LSB(mask) VmaBitScanLSB(mask)
+#endif
+
+#ifndef VMA_BITSCAN_MSB
+    // Scans integer for index of first nonzero value from the Most Significant Bit (MSB). If mask is 0 then returns UINT8_MAX
+    #define VMA_BITSCAN_MSB(mask) VmaBitScanMSB(mask)
+#endif
+
+#ifndef VMA_MIN
+   #define VMA_MIN(v1, v2)    ((std::min)((v1), (v2)))
+#endif
+
+#ifndef VMA_MAX
+   #define VMA_MAX(v1, v2)    ((std::max)((v1), (v2)))
+#endif
+
+#ifndef VMA_SWAP
+   #define VMA_SWAP(v1, v2)   std::swap((v1), (v2))
+#endif
+
+#ifndef VMA_SORT
+   #define VMA_SORT(beg, end, cmp)  std::sort(beg, end, cmp)
+#endif
+
+#ifndef VMA_DEBUG_LOG
+   #define VMA_DEBUG_LOG(format, ...)
+   /*
+   #define VMA_DEBUG_LOG(format, ...) do { \
+       printf(format, __VA_ARGS__); \
+       printf("\n"); \
+   } while(false)
+   */
+#endif
+
+// Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
+#if VMA_STATS_STRING_ENABLED
+    static inline void VmaUint32ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint32_t num)
+    {
+        snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
+    }
+    static inline void VmaUint64ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint64_t num)
+    {
+        snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
+    }
+    static inline void VmaPtrToStr(char* VMA_NOT_NULL outStr, size_t strLen, const void* ptr)
+    {
+        snprintf(outStr, strLen, "%p", ptr);
+    }
+#endif
+
+#ifndef VMA_MUTEX
+    class VmaMutex
+    {
+    public:
+        void Lock() { m_Mutex.lock(); }
+        void Unlock() { m_Mutex.unlock(); }
+        bool TryLock() { return m_Mutex.try_lock(); }
+    private:
+        std::mutex m_Mutex;
+    };
+    #define VMA_MUTEX VmaMutex
+#endif
+
+// Read-write mutex, where "read" is shared access, "write" is exclusive access.
+#ifndef VMA_RW_MUTEX
+    #if VMA_USE_STL_SHARED_MUTEX
+        // Use std::shared_mutex from C++17.
+        #include <shared_mutex>
+        class VmaRWMutex
+        {
+        public:
+            void LockRead() { m_Mutex.lock_shared(); }
+            void UnlockRead() { m_Mutex.unlock_shared(); }
+            bool TryLockRead() { return m_Mutex.try_lock_shared(); }
+            void LockWrite() { m_Mutex.lock(); }
+            void UnlockWrite() { m_Mutex.unlock(); }
+            bool TryLockWrite() { return m_Mutex.try_lock(); }
+        private:
+            std::shared_mutex m_Mutex;
+        };
+        #define VMA_RW_MUTEX VmaRWMutex
+    #elif defined(_WIN32) && defined(WINVER) && WINVER >= 0x0600
+        // Use SRWLOCK from WinAPI.
+        // Minimum supported client = Windows Vista, server = Windows Server 2008.
+        class VmaRWMutex
+        {
+        public:
+            VmaRWMutex() { InitializeSRWLock(&m_Lock); }
+            void LockRead() { AcquireSRWLockShared(&m_Lock); }
+            void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
+            bool TryLockRead() { return TryAcquireSRWLockShared(&m_Lock) != FALSE; }
+            void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
+            void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
+            bool TryLockWrite() { return TryAcquireSRWLockExclusive(&m_Lock) != FALSE; }
+        private:
+            SRWLOCK m_Lock;
+        };
+        #define VMA_RW_MUTEX VmaRWMutex
+    #else
+        // Less efficient fallback: Use normal mutex.
+        class VmaRWMutex
+        {
+        public:
+            void LockRead() { m_Mutex.Lock(); }
+            void UnlockRead() { m_Mutex.Unlock(); }
+            bool TryLockRead() { return m_Mutex.TryLock(); }
+            void LockWrite() { m_Mutex.Lock(); }
+            void UnlockWrite() { m_Mutex.Unlock(); }
+            bool TryLockWrite() { return m_Mutex.TryLock(); }
+        private:
+            VMA_MUTEX m_Mutex;
+        };
+        #define VMA_RW_MUTEX VmaRWMutex
+    #endif // #if VMA_USE_STL_SHARED_MUTEX
+#endif // #ifndef VMA_RW_MUTEX
+
+/*
+If providing your own implementation, you need to implement a subset of std::atomic.
+*/
+#ifndef VMA_ATOMIC_UINT32
+    #include <atomic>
+    #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
+#endif
+
+#ifndef VMA_ATOMIC_UINT64
+    #include <atomic>
+    #define VMA_ATOMIC_UINT64 std::atomic<uint64_t>
+#endif
+
+#ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
+    /**
+    Every allocation will have its own memory block.
+    Define to 1 for debugging purposes only.
+    */
+    #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
+#endif
+
+#ifndef VMA_MIN_ALIGNMENT
+    /**
+    Minimum alignment of all allocations, in bytes.
+    Set to more than 1 for debugging purposes. Must be power of two.
+    */
+    #ifdef VMA_DEBUG_ALIGNMENT // Old name
+        #define VMA_MIN_ALIGNMENT VMA_DEBUG_ALIGNMENT
+    #else
+        #define VMA_MIN_ALIGNMENT (1)
+    #endif
+#endif
+
+#ifndef VMA_DEBUG_MARGIN
+    /**
+    Minimum margin after every allocation, in bytes.
+    Set nonzero for debugging purposes only.
+    */
+    #define VMA_DEBUG_MARGIN (0)
+#endif
+
+#ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
+    /**
+    Define this macro to 1 to automatically fill new allocations and destroyed
+    allocations with some bit pattern.
+    */
+    #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
+#endif
+
+#ifndef VMA_DEBUG_DETECT_CORRUPTION
+    /**
+    Define this macro to 1 together with non-zero value of VMA_DEBUG_MARGIN to
+    enable writing magic value to the margin after every allocation and
+    validating it, so that memory corruptions (out-of-bounds writes) are detected.
+    */
+    #define VMA_DEBUG_DETECT_CORRUPTION (0)
+#endif
+
+#ifndef VMA_DEBUG_GLOBAL_MUTEX
+    /**
+    Set this to 1 for debugging purposes only, to enable single mutex protecting all
+    entry calls to the library. Can be useful for debugging multithreading issues.
+    */
+    #define VMA_DEBUG_GLOBAL_MUTEX (0)
+#endif
+
+#ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
+    /**
+    Minimum value for VkPhysicalDeviceLimits::bufferImageGranularity.
+    Set to more than 1 for debugging purposes only. Must be power of two.
+    */
+    #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
+#endif
+
+#ifndef VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT
+    /*
+    Set this to 1 to make VMA never exceed VkPhysicalDeviceLimits::maxMemoryAllocationCount
+    and return error instead of leaving up to Vulkan implementation what to do in such cases.
+    */
+    #define VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT (0)
+#endif
+
+#ifndef VMA_SMALL_HEAP_MAX_SIZE
+   /// Maximum size of a memory heap in Vulkan to consider it "small".
+   #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
+#endif
+
+#ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
+   /// Default size of a block allocated as single VkDeviceMemory from a "large" heap.
+   #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
+#endif
+
+/*
+Mapping hysteresis is a logic that launches when vmaMapMemory/vmaUnmapMemory is called
+or a persistently mapped allocation is created and destroyed several times in a row.
+It keeps additional +1 mapping of a device memory block to prevent calling actual
+vkMapMemory/vkUnmapMemory too many times, which may improve performance and help
+tools like RenderDOc.
+*/
+#ifndef VMA_MAPPING_HYSTERESIS_ENABLED
+    #define VMA_MAPPING_HYSTERESIS_ENABLED 1
+#endif
+
+#ifndef VMA_CLASS_NO_COPY
+    #define VMA_CLASS_NO_COPY(className) \
+        private: \
+            className(const className&) = delete; \
+            className& operator=(const className&) = delete;
+#endif
+
+#define VMA_VALIDATE(cond) do { if(!(cond)) { \
+        VMA_ASSERT(0 && "Validation failed: " #cond); \
+        return false; \
+    } } while(false)
+
+/*******************************************************************************
+END OF CONFIGURATION
+*/
+#endif // _VMA_CONFIGURATION
+
+
+static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
+static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
+// Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
+static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
+
+// Copy of some Vulkan definitions so we don't need to check their existence just to handle few constants.
+static const uint32_t VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY = 0x00000040;
+static const uint32_t VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY = 0x00000080;
+static const uint32_t VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY = 0x00020000;
+static const uint32_t VK_IMAGE_CREATE_DISJOINT_BIT_COPY = 0x00000200;
+static const int32_t VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT_COPY = 1000158000;
+static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
+static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
+static const uint32_t VMA_VENDOR_ID_AMD = 4098;
+
+// This one is tricky. Vulkan specification defines this code as available since
+// Vulkan 1.0, but doesn't actually define it in Vulkan SDK earlier than 1.2.131.
+// See pull request #207.
+#define VK_ERROR_UNKNOWN_COPY ((VkResult)-13)
+
+
+#if VMA_STATS_STRING_ENABLED
+// Correspond to values of enum VmaSuballocationType.
+static const char* VMA_SUBALLOCATION_TYPE_NAMES[] =
+{
+    "FREE",
+    "UNKNOWN",
+    "BUFFER",
+    "IMAGE_UNKNOWN",
+    "IMAGE_LINEAR",
+    "IMAGE_OPTIMAL",
+};
+#endif
+
+static VkAllocationCallbacks VmaEmptyAllocationCallbacks =
+    { VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
+
+
+#ifndef _VMA_ENUM_DECLARATIONS
+
+enum VmaSuballocationType
+{
+    VMA_SUBALLOCATION_TYPE_FREE = 0,
+    VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
+    VMA_SUBALLOCATION_TYPE_BUFFER = 2,
+    VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
+    VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
+    VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
+    VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+};
+
+enum VMA_CACHE_OPERATION
+{
+    VMA_CACHE_FLUSH,
+    VMA_CACHE_INVALIDATE
+};
+
+enum class VmaAllocationRequestType
+{
+    Normal,
+    TLSF,
+    // Used by "Linear" algorithm.
+    UpperAddress,
+    EndOf1st,
+    EndOf2nd,
+};
+
+#endif // _VMA_ENUM_DECLARATIONS
+
+#ifndef _VMA_FORWARD_DECLARATIONS
+// Opaque handle used by allocation algorithms to identify single allocation in any conforming way.
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VmaAllocHandle);
+
+struct VmaMutexLock;
+struct VmaMutexLockRead;
+struct VmaMutexLockWrite;
+
+template<typename T>
+struct AtomicTransactionalIncrement;
+
+template<typename T>
+struct VmaStlAllocator;
+
+template<typename T, typename AllocatorT>
+class VmaVector;
+
+template<typename T, typename AllocatorT, size_t N>
+class VmaSmallVector;
+
+template<typename T>
+class VmaPoolAllocator;
+
+template<typename T>
+struct VmaListItem;
+
+template<typename T>
+class VmaRawList;
+
+template<typename T, typename AllocatorT>
+class VmaList;
+
+template<typename ItemTypeTraits>
+class VmaIntrusiveLinkedList;
+
+// Unused in this version
+#if 0
+template<typename T1, typename T2>
+struct VmaPair;
+template<typename FirstT, typename SecondT>
+struct VmaPairFirstLess;
+
+template<typename KeyT, typename ValueT>
+class VmaMap;
+#endif
+
+#if VMA_STATS_STRING_ENABLED
+class VmaStringBuilder;
+class VmaJsonWriter;
+#endif
+
+class VmaDeviceMemoryBlock;
+
+struct VmaDedicatedAllocationListItemTraits;
+class VmaDedicatedAllocationList;
+
+struct VmaSuballocation;
+struct VmaSuballocationOffsetLess;
+struct VmaSuballocationOffsetGreater;
+struct VmaSuballocationItemSizeLess;
+
+typedef VmaList<VmaSuballocation, VmaStlAllocator<VmaSuballocation>> VmaSuballocationList;
+
+struct VmaAllocationRequest;
+
+class VmaBlockMetadata;
+class VmaBlockMetadata_Linear;
+class VmaBlockMetadata_TLSF;
+
+class VmaBlockVector;
+
+struct VmaPoolListItemTraits;
+
+struct VmaCurrentBudgetData;
+
+class VmaAllocationObjectAllocator;
+
+#endif // _VMA_FORWARD_DECLARATIONS
+
+
+#ifndef _VMA_FUNCTIONS
+
+/*
+Returns number of bits set to 1 in (v).
+
+On specific platforms and compilers you can use instrinsics like:
+
+Visual Studio:
+    return __popcnt(v);
+GCC, Clang:
+    return static_cast<uint32_t>(__builtin_popcount(v));
+
+Define macro VMA_COUNT_BITS_SET to provide your optimized implementation.
+But you need to check in runtime whether user's CPU supports these, as some old processors don't.
+*/
+static inline uint32_t VmaCountBitsSet(uint32_t v)
+{
+#if __cplusplus >= 202002L || _MSVC_LANG >= 202002L // C++20
+    return std::popcount(v);
+#else
+    uint32_t c = v - ((v >> 1) & 0x55555555);
+    c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
+    c = ((c >> 4) + c) & 0x0F0F0F0F;
+    c = ((c >> 8) + c) & 0x00FF00FF;
+    c = ((c >> 16) + c) & 0x0000FFFF;
+    return c;
+#endif
+}
+
+static inline uint8_t VmaBitScanLSB(uint64_t mask)
+{
+#if defined(_MSC_VER) && defined(_WIN64)
+    unsigned long pos;
+    if (_BitScanForward64(&pos, mask))
+        return static_cast<uint8_t>(pos);
+    return UINT8_MAX;
+#elif defined __GNUC__ || defined __clang__
+    return static_cast<uint8_t>(__builtin_ffsll(mask)) - 1U;
+#else
+    uint8_t pos = 0;
+    uint64_t bit = 1;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit <<= 1;
+    } while (pos++ < 63);
+    return UINT8_MAX;
+#endif
+}
+
+static inline uint8_t VmaBitScanLSB(uint32_t mask)
+{
+#ifdef _MSC_VER
+    unsigned long pos;
+    if (_BitScanForward(&pos, mask))
+        return static_cast<uint8_t>(pos);
+    return UINT8_MAX;
+#elif defined __GNUC__ || defined __clang__
+    return static_cast<uint8_t>(__builtin_ffs(mask)) - 1U;
+#else
+    uint8_t pos = 0;
+    uint32_t bit = 1;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit <<= 1;
+    } while (pos++ < 31);
+    return UINT8_MAX;
+#endif
+}
+
+static inline uint8_t VmaBitScanMSB(uint64_t mask)
+{
+#if defined(_MSC_VER) && defined(_WIN64)
+    unsigned long pos;
+    if (_BitScanReverse64(&pos, mask))
+        return static_cast<uint8_t>(pos);
+#elif defined __GNUC__ || defined __clang__
+    if (mask)
+        return 63 - static_cast<uint8_t>(__builtin_clzll(mask));
+#else
+    uint8_t pos = 63;
+    uint64_t bit = 1ULL << 63;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit >>= 1;
+    } while (pos-- > 0);
+#endif
+    return UINT8_MAX;
+}
+
+static inline uint8_t VmaBitScanMSB(uint32_t mask)
+{
+#ifdef _MSC_VER
+    unsigned long pos;
+    if (_BitScanReverse(&pos, mask))
+        return static_cast<uint8_t>(pos);
+#elif defined __GNUC__ || defined __clang__
+    if (mask)
+        return 31 - static_cast<uint8_t>(__builtin_clz(mask));
+#else
+    uint8_t pos = 31;
+    uint32_t bit = 1UL << 31;
+    do
+    {
+        if (mask & bit)
+            return pos;
+        bit >>= 1;
+    } while (pos-- > 0);
+#endif
+    return UINT8_MAX;
+}
+
+/*
+Returns true if given number is a power of two.
+T must be unsigned integer number or signed integer but always nonnegative.
+For 0 returns true.
+*/
+template <typename T>
+inline bool VmaIsPow2(T x)
+{
+    return (x & (x - 1)) == 0;
+}
+
+// Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
+// Use types like uint32_t, uint64_t as T.
+template <typename T>
+static inline T VmaAlignUp(T val, T alignment)
+{
+    VMA_HEAVY_ASSERT(VmaIsPow2(alignment));
+    return (val + alignment - 1) & ~(alignment - 1);
+}
+
+// Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
+// Use types like uint32_t, uint64_t as T.
+template <typename T>
+static inline T VmaAlignDown(T val, T alignment)
+{
+    VMA_HEAVY_ASSERT(VmaIsPow2(alignment));
+    return val & ~(alignment - 1);
+}
+
+// Division with mathematical rounding to nearest number.
+template <typename T>
+static inline T VmaRoundDiv(T x, T y)
+{
+    return (x + (y / (T)2)) / y;
+}
+
+// Divide by 'y' and round up to nearest integer.
+template <typename T>
+static inline T VmaDivideRoundingUp(T x, T y)
+{
+    return (x + y - (T)1) / y;
+}
+
+// Returns smallest power of 2 greater or equal to v.
+static inline uint32_t VmaNextPow2(uint32_t v)
+{
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v++;
+    return v;
+}
+
+static inline uint64_t VmaNextPow2(uint64_t v)
+{
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v |= v >> 32;
+    v++;
+    return v;
+}
+
+// Returns largest power of 2 less or equal to v.
+static inline uint32_t VmaPrevPow2(uint32_t v)
+{
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v = v ^ (v >> 1);
+    return v;
+}
+
+static inline uint64_t VmaPrevPow2(uint64_t v)
+{
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v |= v >> 32;
+    v = v ^ (v >> 1);
+    return v;
+}
+
+static inline bool VmaStrIsEmpty(const char* pStr)
+{
+    return pStr == VMA_NULL || *pStr == '\0';
+}
+
+/*
+Returns true if two memory blocks occupy overlapping pages.
+ResourceA must be in less memory offset than ResourceB.
+
+Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
+chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
+*/
+static inline bool VmaBlocksOnSamePage(
+    VkDeviceSize resourceAOffset,
+    VkDeviceSize resourceASize,
+    VkDeviceSize resourceBOffset,
+    VkDeviceSize pageSize)
+{
+    VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
+    VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
+    VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
+    VkDeviceSize resourceBStart = resourceBOffset;
+    VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
+    return resourceAEndPage == resourceBStartPage;
+}
+
+/*
+Returns true if given suballocation types could conflict and must respect
+VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
+or linear image and another one is optimal image. If type is unknown, behave
+conservatively.
+*/
+static inline bool VmaIsBufferImageGranularityConflict(
+    VmaSuballocationType suballocType1,
+    VmaSuballocationType suballocType2)
+{
+    if (suballocType1 > suballocType2)
+    {
+        VMA_SWAP(suballocType1, suballocType2);
+    }
+
+    switch (suballocType1)
+    {
+    case VMA_SUBALLOCATION_TYPE_FREE:
+        return false;
+    case VMA_SUBALLOCATION_TYPE_UNKNOWN:
+        return true;
+    case VMA_SUBALLOCATION_TYPE_BUFFER:
+        return
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
+    case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
+        return
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
+    case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
+        return
+            suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
+    case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
+        return false;
+    default:
+        VMA_ASSERT(0);
+        return true;
+    }
+}
+
+static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
+{
+#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
+    uint32_t* pDst = (uint32_t*)((char*)pData + offset);
+    const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
+    for (size_t i = 0; i < numberCount; ++i, ++pDst)
+    {
+        *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
+    }
+#else
+    // no-op
+#endif
+}
+
+static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
+{
+#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
+    const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
+    const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
+    for (size_t i = 0; i < numberCount; ++i, ++pSrc)
+    {
+        if (*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
+        {
+            return false;
+        }
+    }
+#endif
+    return true;
+}
+
+/*
+Fills structure with parameters of an example buffer to be used for transfers
+during GPU memory defragmentation.
+*/
+static void VmaFillGpuDefragmentationBufferCreateInfo(VkBufferCreateInfo& outBufCreateInfo)
+{
+    memset(&outBufCreateInfo, 0, sizeof(outBufCreateInfo));
+    outBufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    outBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    outBufCreateInfo.size = (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE; // Example size.
+}
+
+
+/*
+Performs binary search and returns iterator to first element that is greater or
+equal to (key), according to comparison (cmp).
+
+Cmp should return true if first argument is less than second argument.
+
+Returned value is the found element, if present in the collection or place where
+new element with value (key) should be inserted.
+*/
+template <typename CmpLess, typename IterT, typename KeyT>
+static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp)
+{
+    size_t down = 0, up = (end - beg);
+    while (down < up)
+    {
+        const size_t mid = down + (up - down) / 2;  // Overflow-safe midpoint calculation
+        if (cmp(*(beg + mid), key))
+        {
+            down = mid + 1;
+        }
+        else
+        {
+            up = mid;
+        }
+    }
+    return beg + down;
+}
+
+template<typename CmpLess, typename IterT, typename KeyT>
+IterT VmaBinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
+{
+    IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
+        beg, end, value, cmp);
+    if (it == end ||
+        (!cmp(*it, value) && !cmp(value, *it)))
+    {
+        return it;
+    }
+    return end;
+}
+
+/*
+Returns true if all pointers in the array are not-null and unique.
+Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
+T must be pointer type, e.g. VmaAllocation, VmaPool.
+*/
+template<typename T>
+static bool VmaValidatePointerArray(uint32_t count, const T* arr)
+{
+    for (uint32_t i = 0; i < count; ++i)
+    {
+        const T iPtr = arr[i];
+        if (iPtr == VMA_NULL)
+        {
+            return false;
+        }
+        for (uint32_t j = i + 1; j < count; ++j)
+        {
+            if (iPtr == arr[j])
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+template<typename MainT, typename NewT>
+static inline void VmaPnextChainPushFront(MainT* mainStruct, NewT* newStruct)
+{
+    newStruct->pNext = mainStruct->pNext;
+    mainStruct->pNext = newStruct;
+}
+
+// This is the main algorithm that guides the selection of a memory type best for an allocation -
+// converts usage to required/preferred/not preferred flags.
+static bool FindMemoryPreferences(
+    bool isIntegratedGPU,
+    const VmaAllocationCreateInfo& allocCreateInfo,
+    VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
+    VkMemoryPropertyFlags& outRequiredFlags,
+    VkMemoryPropertyFlags& outPreferredFlags,
+    VkMemoryPropertyFlags& outNotPreferredFlags)
+{
+    outRequiredFlags = allocCreateInfo.requiredFlags;
+    outPreferredFlags = allocCreateInfo.preferredFlags;
+    outNotPreferredFlags = 0;
+
+    switch(allocCreateInfo.usage)
+    {
+    case VMA_MEMORY_USAGE_UNKNOWN:
+        break;
+    case VMA_MEMORY_USAGE_GPU_ONLY:
+        if(!isIntegratedGPU || (outPreferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
+        {
+            outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        }
+        break;
+    case VMA_MEMORY_USAGE_CPU_ONLY:
+        outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+        break;
+    case VMA_MEMORY_USAGE_CPU_TO_GPU:
+        outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+        if(!isIntegratedGPU || (outPreferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
+        {
+            outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        }
+        break;
+    case VMA_MEMORY_USAGE_GPU_TO_CPU:
+        outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+        outPreferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+        break;
+    case VMA_MEMORY_USAGE_CPU_COPY:
+        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        break;
+    case VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED:
+        outRequiredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
+        break;
+    case VMA_MEMORY_USAGE_AUTO:
+    case VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE:
+    case VMA_MEMORY_USAGE_AUTO_PREFER_HOST:
+    {
+        if(bufImgUsage == UINT32_MAX)
+        {
+            VMA_ASSERT(0 && "VMA_MEMORY_USAGE_AUTO* values can only be used with functions like vmaCreateBuffer, vmaCreateImage so that the details of the created resource are known.");
+            return false;
+        }
+        // This relies on values of VK_IMAGE_USAGE_TRANSFER* being the same VK_BUFFER_IMAGE_TRANSFER*.
+        const bool deviceAccess = (bufImgUsage & ~(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) != 0;
+        const bool hostAccessSequentialWrite = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT) != 0;
+        const bool hostAccessRandom = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT) != 0;
+        const bool hostAccessAllowTransferInstead = (allocCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT) != 0;
+        const bool preferDevice = allocCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
+        const bool preferHost = allocCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_HOST;
+
+        // CPU random access - e.g. a buffer written to or transferred from GPU to read back on CPU.
+        if(hostAccessRandom)
+        {
+            if(!isIntegratedGPU && deviceAccess && hostAccessAllowTransferInstead && !preferHost)
+            {
+                // Nice if it will end up in HOST_VISIBLE, but more importantly prefer DEVICE_LOCAL.
+                // Omitting HOST_VISIBLE here is intentional.
+                // In case there is DEVICE_LOCAL | HOST_VISIBLE | HOST_CACHED, it will pick that one.
+                // Otherwise, this will give same weight to DEVICE_LOCAL as HOST_VISIBLE | HOST_CACHED and select the former if occurs first on the list.
+                outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+            }
+            else
+            {
+                // Always CPU memory, cached.
+                outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+            }
+        }
+        // CPU sequential write - may be CPU or host-visible GPU memory, uncached and write-combined.
+        else if(hostAccessSequentialWrite)
+        {
+            // Want uncached and write-combined.
+            outNotPreferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+
+            if(!isIntegratedGPU && deviceAccess && hostAccessAllowTransferInstead && !preferHost)
+            {
+                outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+            }
+            else
+            {
+                outRequiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+                // Direct GPU access, CPU sequential write (e.g. a dynamic uniform buffer updated every frame)
+                if(deviceAccess)
+                {
+                    // Could go to CPU memory or GPU BAR/unified. Up to the user to decide. If no preference, choose GPU memory.
+                    if(preferHost)
+                        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                    else
+                        outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                }
+                // GPU no direct access, CPU sequential write (e.g. an upload buffer to be transferred to the GPU)
+                else
+                {
+                    // Could go to CPU memory or GPU BAR/unified. Up to the user to decide. If no preference, choose CPU memory.
+                    if(preferDevice)
+                        outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                    else
+                        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                }
+            }
+        }
+        // No CPU access
+        else
+        {
+            // GPU access, no CPU access (e.g. a color attachment image) - prefer GPU memory
+            if(deviceAccess)
+            {
+                // ...unless there is a clear preference from the user not to do so.
+                if(preferHost)
+                    outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+                else
+                    outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+            }
+            // No direct GPU access, no CPU access, just transfers.
+            // It may be staging copy intended for e.g. preserving image for next frame (then better GPU memory) or
+            // a "swap file" copy to free some GPU memory (then better CPU memory).
+            // Up to the user to decide. If no preferece, assume the former and choose GPU memory.
+            if(preferHost)
+                outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+            else
+                outPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+        }
+        break;
+    }
+    default:
+        VMA_ASSERT(0);
+    }
+
+    // Avoid DEVICE_COHERENT unless explicitly requested.
+    if(((allocCreateInfo.requiredFlags | allocCreateInfo.preferredFlags) &
+        (VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY | VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY)) == 0)
+    {
+        outNotPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY;
+    }
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Memory allocation
+
+static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
+{
+    void* result = VMA_NULL;
+    if ((pAllocationCallbacks != VMA_NULL) &&
+        (pAllocationCallbacks->pfnAllocation != VMA_NULL))
+    {
+        result = (*pAllocationCallbacks->pfnAllocation)(
+            pAllocationCallbacks->pUserData,
+            size,
+            alignment,
+            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+    }
+    else
+    {
+        result = VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
+    }
+    VMA_ASSERT(result != VMA_NULL && "CPU memory allocation failed.");
+    return result;
+}
+
+static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
+{
+    if ((pAllocationCallbacks != VMA_NULL) &&
+        (pAllocationCallbacks->pfnFree != VMA_NULL))
+    {
+        (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
+    }
+    else
+    {
+        VMA_SYSTEM_ALIGNED_FREE(ptr);
+    }
+}
+
+template<typename T>
+static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
+{
+    return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
+}
+
+template<typename T>
+static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
+{
+    return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
+}
+
+#define vma_new(allocator, type)   new(VmaAllocate<type>(allocator))(type)
+
+#define vma_new_array(allocator, type, count)   new(VmaAllocateArray<type>((allocator), (count)))(type)
+
+template<typename T>
+static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
+{
+    ptr->~T();
+    VmaFree(pAllocationCallbacks, ptr);
+}
+
+template<typename T>
+static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
+{
+    if (ptr != VMA_NULL)
+    {
+        for (size_t i = count; i--; )
+        {
+            ptr[i].~T();
+        }
+        VmaFree(pAllocationCallbacks, ptr);
+    }
+}
+
+static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr)
+{
+    if (srcStr != VMA_NULL)
+    {
+        const size_t len = strlen(srcStr);
+        char* const result = vma_new_array(allocs, char, len + 1);
+        memcpy(result, srcStr, len + 1);
+        return result;
+    }
+    return VMA_NULL;
+}
+
+#if VMA_STATS_STRING_ENABLED
+static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr, size_t strLen)
+{
+    if (srcStr != VMA_NULL)
+    {
+        char* const result = vma_new_array(allocs, char, strLen + 1);
+        memcpy(result, srcStr, strLen);
+        result[strLen] = '\0';
+        return result;
+    }
+    return VMA_NULL;
+}
+#endif // VMA_STATS_STRING_ENABLED
+
+static void VmaFreeString(const VkAllocationCallbacks* allocs, char* str)
+{
+    if (str != VMA_NULL)
+    {
+        const size_t len = strlen(str);
+        vma_delete_array(allocs, str, len + 1);
+    }
+}
+
+template<typename CmpLess, typename VectorT>
+size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
+{
+    const size_t indexToInsert = VmaBinaryFindFirstNotLess(
+        vector.data(),
+        vector.data() + vector.size(),
+        value,
+        CmpLess()) - vector.data();
+    VmaVectorInsert(vector, indexToInsert, value);
+    return indexToInsert;
+}
+
+template<typename CmpLess, typename VectorT>
+bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
+{
+    CmpLess comparator;
+    typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
+        vector.begin(),
+        vector.end(),
+        value,
+        comparator);
+    if ((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
+    {
+        size_t indexToRemove = it - vector.begin();
+        VmaVectorRemove(vector, indexToRemove);
+        return true;
+    }
+    return false;
+}
+#endif // _VMA_FUNCTIONS
+
+#ifndef _VMA_STATISTICS_FUNCTIONS
+
+static void VmaClearStatistics(VmaStatistics& outStats)
+{
+    outStats.blockCount = 0;
+    outStats.allocationCount = 0;
+    outStats.blockBytes = 0;
+    outStats.allocationBytes = 0;
+}
+
+static void VmaAddStatistics(VmaStatistics& inoutStats, const VmaStatistics& src)
+{
+    inoutStats.blockCount += src.blockCount;
+    inoutStats.allocationCount += src.allocationCount;
+    inoutStats.blockBytes += src.blockBytes;
+    inoutStats.allocationBytes += src.allocationBytes;
+}
+
+static void VmaClearDetailedStatistics(VmaDetailedStatistics& outStats)
+{
+    VmaClearStatistics(outStats.statistics);
+    outStats.unusedRangeCount = 0;
+    outStats.allocationSizeMin = VK_WHOLE_SIZE;
+    outStats.allocationSizeMax = 0;
+    outStats.unusedRangeSizeMin = VK_WHOLE_SIZE;
+    outStats.unusedRangeSizeMax = 0;
+}
+
+static void VmaAddDetailedStatisticsAllocation(VmaDetailedStatistics& inoutStats, VkDeviceSize size)
+{
+    inoutStats.statistics.allocationCount++;
+    inoutStats.statistics.allocationBytes += size;
+    inoutStats.allocationSizeMin = VMA_MIN(inoutStats.allocationSizeMin, size);
+    inoutStats.allocationSizeMax = VMA_MAX(inoutStats.allocationSizeMax, size);
+}
+
+static void VmaAddDetailedStatisticsUnusedRange(VmaDetailedStatistics& inoutStats, VkDeviceSize size)
+{
+    inoutStats.unusedRangeCount++;
+    inoutStats.unusedRangeSizeMin = VMA_MIN(inoutStats.unusedRangeSizeMin, size);
+    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, size);
+}
+
+static void VmaAddDetailedStatistics(VmaDetailedStatistics& inoutStats, const VmaDetailedStatistics& src)
+{
+    VmaAddStatistics(inoutStats.statistics, src.statistics);
+    inoutStats.unusedRangeCount += src.unusedRangeCount;
+    inoutStats.allocationSizeMin = VMA_MIN(inoutStats.allocationSizeMin, src.allocationSizeMin);
+    inoutStats.allocationSizeMax = VMA_MAX(inoutStats.allocationSizeMax, src.allocationSizeMax);
+    inoutStats.unusedRangeSizeMin = VMA_MIN(inoutStats.unusedRangeSizeMin, src.unusedRangeSizeMin);
+    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, src.unusedRangeSizeMax);
+}
+
+#endif // _VMA_STATISTICS_FUNCTIONS
+
+#ifndef _VMA_MUTEX_LOCK
+// Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
+struct VmaMutexLock
+{
+    VMA_CLASS_NO_COPY(VmaMutexLock)
+public:
+    VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
+        m_pMutex(useMutex ? &mutex : VMA_NULL)
+    {
+        if (m_pMutex) { m_pMutex->Lock(); }
+    }
+    ~VmaMutexLock() {  if (m_pMutex) { m_pMutex->Unlock(); } }
+
+private:
+    VMA_MUTEX* m_pMutex;
+};
+
+// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
+struct VmaMutexLockRead
+{
+    VMA_CLASS_NO_COPY(VmaMutexLockRead)
+public:
+    VmaMutexLockRead(VMA_RW_MUTEX& mutex, bool useMutex) :
+        m_pMutex(useMutex ? &mutex : VMA_NULL)
+    {
+        if (m_pMutex) { m_pMutex->LockRead(); }
+    }
+    ~VmaMutexLockRead() { if (m_pMutex) { m_pMutex->UnlockRead(); } }
+
+private:
+    VMA_RW_MUTEX* m_pMutex;
+};
+
+// Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
+struct VmaMutexLockWrite
+{
+    VMA_CLASS_NO_COPY(VmaMutexLockWrite)
+public:
+    VmaMutexLockWrite(VMA_RW_MUTEX& mutex, bool useMutex)
+        : m_pMutex(useMutex ? &mutex : VMA_NULL)
+    {
+        if (m_pMutex) { m_pMutex->LockWrite(); }
+    }
+    ~VmaMutexLockWrite() { if (m_pMutex) { m_pMutex->UnlockWrite(); } }
+
+private:
+    VMA_RW_MUTEX* m_pMutex;
+};
+
+#if VMA_DEBUG_GLOBAL_MUTEX
+    static VMA_MUTEX gDebugGlobalMutex;
+    #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
+#else
+    #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
+#endif
+#endif // _VMA_MUTEX_LOCK
+
+#ifndef _VMA_ATOMIC_TRANSACTIONAL_INCREMENT
+// An object that increments given atomic but decrements it back in the destructor unless Commit() is called.
+template<typename T>
+struct AtomicTransactionalIncrement
+{
+public:
+    typedef std::atomic<T> AtomicT;
+
+    ~AtomicTransactionalIncrement()
+    {
+        if(m_Atomic)
+            --(*m_Atomic);
+    }
+
+    void Commit() { m_Atomic = nullptr; }
+    T Increment(AtomicT* atomic)
+    {
+        m_Atomic = atomic;
+        return m_Atomic->fetch_add(1);
+    }
+
+private:
+    AtomicT* m_Atomic = nullptr;
+};
+#endif // _VMA_ATOMIC_TRANSACTIONAL_INCREMENT
+
+#ifndef _VMA_STL_ALLOCATOR
+// STL-compatible allocator.
+template<typename T>
+struct VmaStlAllocator
+{
+    const VkAllocationCallbacks* const m_pCallbacks;
+    typedef T value_type;
+
+    VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) {}
+    template<typename U>
+    VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) {}
+    VmaStlAllocator(const VmaStlAllocator&) = default;
+    VmaStlAllocator& operator=(const VmaStlAllocator&) = delete;
+
+    T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
+    void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
+
+    template<typename U>
+    bool operator==(const VmaStlAllocator<U>& rhs) const
+    {
+        return m_pCallbacks == rhs.m_pCallbacks;
+    }
+    template<typename U>
+    bool operator!=(const VmaStlAllocator<U>& rhs) const
+    {
+        return m_pCallbacks != rhs.m_pCallbacks;
+    }
+};
+#endif // _VMA_STL_ALLOCATOR
+
+#ifndef _VMA_VECTOR
+/* Class with interface compatible with subset of std::vector.
+T must be POD because constructors and destructors are not called and memcpy is
+used for these objects. */
+template<typename T, typename AllocatorT>
+class VmaVector
+{
+public:
+    typedef T value_type;
+    typedef T* iterator;
+    typedef const T* const_iterator;
+
+    VmaVector(const AllocatorT& allocator);
+    VmaVector(size_t count, const AllocatorT& allocator);
+    // This version of the constructor is here for compatibility with pre-C++14 std::vector.
+    // value is unused.
+    VmaVector(size_t count, const T& value, const AllocatorT& allocator) : VmaVector(count, allocator) {}
+    VmaVector(const VmaVector<T, AllocatorT>& src);
+    VmaVector& operator=(const VmaVector& rhs);
+    ~VmaVector() { VmaFree(m_Allocator.m_pCallbacks, m_pArray); }
+
+    bool empty() const { return m_Count == 0; }
+    size_t size() const { return m_Count; }
+    T* data() { return m_pArray; }
+    T& front() { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[0]; }
+    T& back() { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[m_Count - 1]; }
+    const T* data() const { return m_pArray; }
+    const T& front() const { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[0]; }
+    const T& back() const { VMA_HEAVY_ASSERT(m_Count > 0); return m_pArray[m_Count - 1]; }
+
+    iterator begin() { return m_pArray; }
+    iterator end() { return m_pArray + m_Count; }
+    const_iterator cbegin() const { return m_pArray; }
+    const_iterator cend() const { return m_pArray + m_Count; }
+    const_iterator begin() const { return cbegin(); }
+    const_iterator end() const { return cend(); }
+
+    void pop_front() { VMA_HEAVY_ASSERT(m_Count > 0); remove(0); }
+    void pop_back() { VMA_HEAVY_ASSERT(m_Count > 0); resize(size() - 1); }
+    void push_front(const T& src) { insert(0, src); }
+
+    void push_back(const T& src);
+    void reserve(size_t newCapacity, bool freeMemory = false);
+    void resize(size_t newCount);
+    void clear() { resize(0); }
+    void shrink_to_fit();
+    void insert(size_t index, const T& src);
+    void remove(size_t index);
+
+    T& operator[](size_t index) { VMA_HEAVY_ASSERT(index < m_Count); return m_pArray[index]; }
+    const T& operator[](size_t index) const { VMA_HEAVY_ASSERT(index < m_Count); return m_pArray[index]; }
+
+private:
+    AllocatorT m_Allocator;
+    T* m_pArray;
+    size_t m_Count;
+    size_t m_Capacity;
+};
+
+#ifndef _VMA_VECTOR_FUNCTIONS
+template<typename T, typename AllocatorT>
+VmaVector<T, AllocatorT>::VmaVector(const AllocatorT& allocator)
+    : m_Allocator(allocator),
+    m_pArray(VMA_NULL),
+    m_Count(0),
+    m_Capacity(0) {}
+
+template<typename T, typename AllocatorT>
+VmaVector<T, AllocatorT>::VmaVector(size_t count, const AllocatorT& allocator)
+    : m_Allocator(allocator),
+    m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
+    m_Count(count),
+    m_Capacity(count) {}
+
+template<typename T, typename AllocatorT>
+VmaVector<T, AllocatorT>::VmaVector(const VmaVector& src)
+    : m_Allocator(src.m_Allocator),
+    m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
+    m_Count(src.m_Count),
+    m_Capacity(src.m_Count)
+{
+    if (m_Count != 0)
+    {
+        memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
+    }
+}
+
+template<typename T, typename AllocatorT>
+VmaVector<T, AllocatorT>& VmaVector<T, AllocatorT>::operator=(const VmaVector& rhs)
+{
+    if (&rhs != this)
+    {
+        resize(rhs.m_Count);
+        if (m_Count != 0)
+        {
+            memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
+        }
+    }
+    return *this;
+}
+
+template<typename T, typename AllocatorT>
+void VmaVector<T, AllocatorT>::push_back(const T& src)
+{
+    const size_t newIndex = size();
+    resize(newIndex + 1);
+    m_pArray[newIndex] = src;
+}
+
+template<typename T, typename AllocatorT>
+void VmaVector<T, AllocatorT>::reserve(size_t newCapacity, bool freeMemory)
+{
+    newCapacity = VMA_MAX(newCapacity, m_Count);
+
+    if ((newCapacity < m_Capacity) && !freeMemory)
+    {
+        newCapacity = m_Capacity;
+    }
+
+    if (newCapacity != m_Capacity)
+    {
+        T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
+        if (m_Count != 0)
+        {
+            memcpy(newArray, m_pArray, m_Count * sizeof(T));
+        }
+        VmaFree(m_Allocator.m_pCallbacks, m_pArray);
+        m_Capacity = newCapacity;
+        m_pArray = newArray;
+    }
+}
+
+template<typename T, typename AllocatorT>
+void VmaVector<T, AllocatorT>::resize(size_t newCount)
+{
+    size_t newCapacity = m_Capacity;
+    if (newCount > m_Capacity)
+    {
+        newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
+    }
+
+    if (newCapacity != m_Capacity)
+    {
+        T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
+        const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
+        if (elementsToCopy != 0)
+        {
+            memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
+        }
+        VmaFree(m_Allocator.m_pCallbacks, m_pArray);
+        m_Capacity = newCapacity;
+        m_pArray = newArray;
+    }
+
+    m_Count = newCount;
+}
+
+template<typename T, typename AllocatorT>
+void VmaVector<T, AllocatorT>::shrink_to_fit()
+{
+    if (m_Capacity > m_Count)
+    {
+        T* newArray = VMA_NULL;
+        if (m_Count > 0)
+        {
+            newArray = VmaAllocateArray<T>(m_Allocator.m_pCallbacks, m_Count);
+            memcpy(newArray, m_pArray, m_Count * sizeof(T));
+        }
+        VmaFree(m_Allocator.m_pCallbacks, m_pArray);
+        m_Capacity = m_Count;
+        m_pArray = newArray;
+    }
+}
+
+template<typename T, typename AllocatorT>
+void VmaVector<T, AllocatorT>::insert(size_t index, const T& src)
+{
+    VMA_HEAVY_ASSERT(index <= m_Count);
+    const size_t oldCount = size();
+    resize(oldCount + 1);
+    if (index < oldCount)
+    {
+        memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
+    }
+    m_pArray[index] = src;
+}
+
+template<typename T, typename AllocatorT>
+void VmaVector<T, AllocatorT>::remove(size_t index)
+{
+    VMA_HEAVY_ASSERT(index < m_Count);
+    const size_t oldCount = size();
+    if (index < oldCount - 1)
+    {
+        memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
+    }
+    resize(oldCount - 1);
+}
+#endif // _VMA_VECTOR_FUNCTIONS
+
+template<typename T, typename allocatorT>
+static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
+{
+    vec.insert(index, item);
+}
+
+template<typename T, typename allocatorT>
+static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
+{
+    vec.remove(index);
+}
+#endif // _VMA_VECTOR
+
+#ifndef _VMA_SMALL_VECTOR
+/*
+This is a vector (a variable-sized array), optimized for the case when the array is small.
+
+It contains some number of elements in-place, which allows it to avoid heap allocation
+when the actual number of elements is below that threshold. This allows normal "small"
+cases to be fast without losing generality for large inputs.
+*/
+template<typename T, typename AllocatorT, size_t N>
+class VmaSmallVector
+{
+public:
+    typedef T value_type;
+    typedef T* iterator;
+
+    VmaSmallVector(const AllocatorT& allocator);
+    VmaSmallVector(size_t count, const AllocatorT& allocator);
+    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>
+    VmaSmallVector(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>&) = delete;
+    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>
+    VmaSmallVector<T, AllocatorT, N>& operator=(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>&) = delete;
+    ~VmaSmallVector() = default;
+
+    bool empty() const { return m_Count == 0; }
+    size_t size() const { return m_Count; }
+    T* data() { return m_Count > N ? m_DynamicArray.data() : m_StaticArray; }
+    T& front() { VMA_HEAVY_ASSERT(m_Count > 0); return data()[0]; }
+    T& back() { VMA_HEAVY_ASSERT(m_Count > 0); return data()[m_Count - 1]; }
+    const T* data() const { return m_Count > N ? m_DynamicArray.data() : m_StaticArray; }
+    const T& front() const { VMA_HEAVY_ASSERT(m_Count > 0); return data()[0]; }
+    const T& back() const { VMA_HEAVY_ASSERT(m_Count > 0); return data()[m_Count - 1]; }
+
+    iterator begin() { return data(); }
+    iterator end() { return data() + m_Count; }
+
+    void pop_front() { VMA_HEAVY_ASSERT(m_Count > 0); remove(0); }
+    void pop_back() { VMA_HEAVY_ASSERT(m_Count > 0); resize(size() - 1); }
+    void push_front(const T& src) { insert(0, src); }
+
+    void push_back(const T& src);
+    void resize(size_t newCount, bool freeMemory = false);
+    void clear(bool freeMemory = false);
+    void insert(size_t index, const T& src);
+    void remove(size_t index);
+
+    T& operator[](size_t index) { VMA_HEAVY_ASSERT(index < m_Count); return data()[index]; }
+    const T& operator[](size_t index) const { VMA_HEAVY_ASSERT(index < m_Count); return data()[index]; }
+
+private:
+    size_t m_Count;
+    T m_StaticArray[N]; // Used when m_Size <= N
+    VmaVector<T, AllocatorT> m_DynamicArray; // Used when m_Size > N
+};
+
+#ifndef _VMA_SMALL_VECTOR_FUNCTIONS
+template<typename T, typename AllocatorT, size_t N>
+VmaSmallVector<T, AllocatorT, N>::VmaSmallVector(const AllocatorT& allocator)
+    : m_Count(0),
+    m_DynamicArray(allocator) {}
+
+template<typename T, typename AllocatorT, size_t N>
+VmaSmallVector<T, AllocatorT, N>::VmaSmallVector(size_t count, const AllocatorT& allocator)
+    : m_Count(count),
+    m_DynamicArray(count > N ? count : 0, allocator) {}
+
+template<typename T, typename AllocatorT, size_t N>
+void VmaSmallVector<T, AllocatorT, N>::push_back(const T& src)
+{
+    const size_t newIndex = size();
+    resize(newIndex + 1);
+    data()[newIndex] = src;
+}
+
+template<typename T, typename AllocatorT, size_t N>
+void VmaSmallVector<T, AllocatorT, N>::resize(size_t newCount, bool freeMemory)
+{
+    if (newCount > N && m_Count > N)
+    {
+        // Any direction, staying in m_DynamicArray
+        m_DynamicArray.resize(newCount);
+        if (freeMemory)
+        {
+            m_DynamicArray.shrink_to_fit();
+        }
+    }
+    else if (newCount > N && m_Count <= N)
+    {
+        // Growing, moving from m_StaticArray to m_DynamicArray
+        m_DynamicArray.resize(newCount);
+        if (m_Count > 0)
+        {
+            memcpy(m_DynamicArray.data(), m_StaticArray, m_Count * sizeof(T));
+        }
+    }
+    else if (newCount <= N && m_Count > N)
+    {
+        // Shrinking, moving from m_DynamicArray to m_StaticArray
+        if (newCount > 0)
+        {
+            memcpy(m_StaticArray, m_DynamicArray.data(), newCount * sizeof(T));
+        }
+        m_DynamicArray.resize(0);
+        if (freeMemory)
+        {
+            m_DynamicArray.shrink_to_fit();
+        }
+    }
+    else
+    {
+        // Any direction, staying in m_StaticArray - nothing to do here
+    }
+    m_Count = newCount;
+}
+
+template<typename T, typename AllocatorT, size_t N>
+void VmaSmallVector<T, AllocatorT, N>::clear(bool freeMemory)
+{
+    m_DynamicArray.clear();
+    if (freeMemory)
+    {
+        m_DynamicArray.shrink_to_fit();
+    }
+    m_Count = 0;
+}
+
+template<typename T, typename AllocatorT, size_t N>
+void VmaSmallVector<T, AllocatorT, N>::insert(size_t index, const T& src)
+{
+    VMA_HEAVY_ASSERT(index <= m_Count);
+    const size_t oldCount = size();
+    resize(oldCount + 1);
+    T* const dataPtr = data();
+    if (index < oldCount)
+    {
+        //  I know, this could be more optimal for case where memmove can be memcpy directly from m_StaticArray to m_DynamicArray.
+        memmove(dataPtr + (index + 1), dataPtr + index, (oldCount - index) * sizeof(T));
+    }
+    dataPtr[index] = src;
+}
+
+template<typename T, typename AllocatorT, size_t N>
+void VmaSmallVector<T, AllocatorT, N>::remove(size_t index)
+{
+    VMA_HEAVY_ASSERT(index < m_Count);
+    const size_t oldCount = size();
+    if (index < oldCount - 1)
+    {
+        //  I know, this could be more optimal for case where memmove can be memcpy directly from m_DynamicArray to m_StaticArray.
+        T* const dataPtr = data();
+        memmove(dataPtr + index, dataPtr + (index + 1), (oldCount - index - 1) * sizeof(T));
+    }
+    resize(oldCount - 1);
+}
+#endif // _VMA_SMALL_VECTOR_FUNCTIONS
+#endif // _VMA_SMALL_VECTOR
+
+#ifndef _VMA_POOL_ALLOCATOR
+/*
+Allocator for objects of type T using a list of arrays (pools) to speed up
+allocation. Number of elements that can be allocated is not bounded because
+allocator can create multiple blocks.
+*/
+template<typename T>
+class VmaPoolAllocator
+{
+    VMA_CLASS_NO_COPY(VmaPoolAllocator)
+public:
+    VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity);
+    ~VmaPoolAllocator();
+    template<typename... Types> T* Alloc(Types&&... args);
+    void Free(T* ptr);
+
+private:
+    union Item
+    {
+        uint32_t NextFreeIndex;
+        alignas(T) char Value[sizeof(T)];
+    };
+    struct ItemBlock
+    {
+        Item* pItems;
+        uint32_t Capacity;
+        uint32_t FirstFreeIndex;
+    };
+
+    const VkAllocationCallbacks* m_pAllocationCallbacks;
+    const uint32_t m_FirstBlockCapacity;
+    VmaVector<ItemBlock, VmaStlAllocator<ItemBlock>> m_ItemBlocks;
+
+    ItemBlock& CreateNewBlock();
+};
+
+#ifndef _VMA_POOL_ALLOCATOR_FUNCTIONS
+template<typename T>
+VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity)
+    : m_pAllocationCallbacks(pAllocationCallbacks),
+    m_FirstBlockCapacity(firstBlockCapacity),
+    m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
+{
+    VMA_ASSERT(m_FirstBlockCapacity > 1);
+}
+
+template<typename T>
+VmaPoolAllocator<T>::~VmaPoolAllocator()
+{
+    for (size_t i = m_ItemBlocks.size(); i--;)
+        vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
+    m_ItemBlocks.clear();
+}
+
+template<typename T>
+template<typename... Types> T* VmaPoolAllocator<T>::Alloc(Types&&... args)
+{
+    for (size_t i = m_ItemBlocks.size(); i--; )
+    {
+        ItemBlock& block = m_ItemBlocks[i];
+        // This block has some free items: Use first one.
+        if (block.FirstFreeIndex != UINT32_MAX)
+        {
+            Item* const pItem = &block.pItems[block.FirstFreeIndex];
+            block.FirstFreeIndex = pItem->NextFreeIndex;
+            T* result = (T*)&pItem->Value;
+            new(result)T(std::forward<Types>(args)...); // Explicit constructor call.
+            return result;
+        }
+    }
+
+    // No block has free item: Create new one and use it.
+    ItemBlock& newBlock = CreateNewBlock();
+    Item* const pItem = &newBlock.pItems[0];
+    newBlock.FirstFreeIndex = pItem->NextFreeIndex;
+    T* result = (T*)&pItem->Value;
+    new(result) T(std::forward<Types>(args)...); // Explicit constructor call.
+    return result;
+}
+
+template<typename T>
+void VmaPoolAllocator<T>::Free(T* ptr)
+{
+    // Search all memory blocks to find ptr.
+    for (size_t i = m_ItemBlocks.size(); i--; )
+    {
+        ItemBlock& block = m_ItemBlocks[i];
+
+        // Casting to union.
+        Item* pItemPtr;
+        memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
+
+        // Check if pItemPtr is in address range of this block.
+        if ((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
+        {
+            ptr->~T(); // Explicit destructor call.
+            const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
+            pItemPtr->NextFreeIndex = block.FirstFreeIndex;
+            block.FirstFreeIndex = index;
+            return;
+        }
+    }
+    VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
+}
+
+template<typename T>
+typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
+{
+    const uint32_t newBlockCapacity = m_ItemBlocks.empty() ?
+        m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;
+
+    const ItemBlock newBlock =
+    {
+        vma_new_array(m_pAllocationCallbacks, Item, newBlockCapacity),
+        newBlockCapacity,
+        0
+    };
+
+    m_ItemBlocks.push_back(newBlock);
+
+    // Setup singly-linked list of all free items in this block.
+    for (uint32_t i = 0; i < newBlockCapacity - 1; ++i)
+        newBlock.pItems[i].NextFreeIndex = i + 1;
+    newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
+    return m_ItemBlocks.back();
+}
+#endif // _VMA_POOL_ALLOCATOR_FUNCTIONS
+#endif // _VMA_POOL_ALLOCATOR
+
+#ifndef _VMA_RAW_LIST
+template<typename T>
+struct VmaListItem
+{
+    VmaListItem* pPrev;
+    VmaListItem* pNext;
+    T Value;
+};
+
+// Doubly linked list.
+template<typename T>
+class VmaRawList
+{
+    VMA_CLASS_NO_COPY(VmaRawList)
+public:
+    typedef VmaListItem<T> ItemType;
+
+    VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
+    // Intentionally not calling Clear, because that would be unnecessary
+    // computations to return all items to m_ItemAllocator as free.
+    ~VmaRawList() = default;
+
+    size_t GetCount() const { return m_Count; }
+    bool IsEmpty() const { return m_Count == 0; }
+
+    ItemType* Front() { return m_pFront; }
+    ItemType* Back() { return m_pBack; }
+    const ItemType* Front() const { return m_pFront; }
+    const ItemType* Back() const { return m_pBack; }
+
+    ItemType* PushFront();
+    ItemType* PushBack();
+    ItemType* PushFront(const T& value);
+    ItemType* PushBack(const T& value);
+    void PopFront();
+    void PopBack();
+
+    // Item can be null - it means PushBack.
+    ItemType* InsertBefore(ItemType* pItem);
+    // Item can be null - it means PushFront.
+    ItemType* InsertAfter(ItemType* pItem);
+    ItemType* InsertBefore(ItemType* pItem, const T& value);
+    ItemType* InsertAfter(ItemType* pItem, const T& value);
+
+    void Clear();
+    void Remove(ItemType* pItem);
+
+private:
+    const VkAllocationCallbacks* const m_pAllocationCallbacks;
+    VmaPoolAllocator<ItemType> m_ItemAllocator;
+    ItemType* m_pFront;
+    ItemType* m_pBack;
+    size_t m_Count;
+};
+
+#ifndef _VMA_RAW_LIST_FUNCTIONS
+template<typename T>
+VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks)
+    : m_pAllocationCallbacks(pAllocationCallbacks),
+    m_ItemAllocator(pAllocationCallbacks, 128),
+    m_pFront(VMA_NULL),
+    m_pBack(VMA_NULL),
+    m_Count(0) {}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushFront()
+{
+    ItemType* const pNewItem = m_ItemAllocator.Alloc();
+    pNewItem->pPrev = VMA_NULL;
+    if (IsEmpty())
+    {
+        pNewItem->pNext = VMA_NULL;
+        m_pFront = pNewItem;
+        m_pBack = pNewItem;
+        m_Count = 1;
+    }
+    else
+    {
+        pNewItem->pNext = m_pFront;
+        m_pFront->pPrev = pNewItem;
+        m_pFront = pNewItem;
+        ++m_Count;
+    }
+    return pNewItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushBack()
+{
+    ItemType* const pNewItem = m_ItemAllocator.Alloc();
+    pNewItem->pNext = VMA_NULL;
+    if(IsEmpty())
+    {
+        pNewItem->pPrev = VMA_NULL;
+        m_pFront = pNewItem;
+        m_pBack = pNewItem;
+        m_Count = 1;
+    }
+    else
+    {
+        pNewItem->pPrev = m_pBack;
+        m_pBack->pNext = pNewItem;
+        m_pBack = pNewItem;
+        ++m_Count;
+    }
+    return pNewItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
+{
+    ItemType* const pNewItem = PushFront();
+    pNewItem->Value = value;
+    return pNewItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
+{
+    ItemType* const pNewItem = PushBack();
+    pNewItem->Value = value;
+    return pNewItem;
+}
+
+template<typename T>
+void VmaRawList<T>::PopFront()
+{
+    VMA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const pFrontItem = m_pFront;
+    ItemType* const pNextItem = pFrontItem->pNext;
+    if (pNextItem != VMA_NULL)
+    {
+        pNextItem->pPrev = VMA_NULL;
+    }
+    m_pFront = pNextItem;
+    m_ItemAllocator.Free(pFrontItem);
+    --m_Count;
+}
+
+template<typename T>
+void VmaRawList<T>::PopBack()
+{
+    VMA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const pBackItem = m_pBack;
+    ItemType* const pPrevItem = pBackItem->pPrev;
+    if(pPrevItem != VMA_NULL)
+    {
+        pPrevItem->pNext = VMA_NULL;
+    }
+    m_pBack = pPrevItem;
+    m_ItemAllocator.Free(pBackItem);
+    --m_Count;
+}
+
+template<typename T>
+void VmaRawList<T>::Clear()
+{
+    if (IsEmpty() == false)
+    {
+        ItemType* pItem = m_pBack;
+        while (pItem != VMA_NULL)
+        {
+            ItemType* const pPrevItem = pItem->pPrev;
+            m_ItemAllocator.Free(pItem);
+            pItem = pPrevItem;
+        }
+        m_pFront = VMA_NULL;
+        m_pBack = VMA_NULL;
+        m_Count = 0;
+    }
+}
+
+template<typename T>
+void VmaRawList<T>::Remove(ItemType* pItem)
+{
+    VMA_HEAVY_ASSERT(pItem != VMA_NULL);
+    VMA_HEAVY_ASSERT(m_Count > 0);
+
+    if(pItem->pPrev != VMA_NULL)
+    {
+        pItem->pPrev->pNext = pItem->pNext;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(m_pFront == pItem);
+        m_pFront = pItem->pNext;
+    }
+
+    if(pItem->pNext != VMA_NULL)
+    {
+        pItem->pNext->pPrev = pItem->pPrev;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(m_pBack == pItem);
+        m_pBack = pItem->pPrev;
+    }
+
+    m_ItemAllocator.Free(pItem);
+    --m_Count;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
+{
+    if(pItem != VMA_NULL)
+    {
+        ItemType* const prevItem = pItem->pPrev;
+        ItemType* const newItem = m_ItemAllocator.Alloc();
+        newItem->pPrev = prevItem;
+        newItem->pNext = pItem;
+        pItem->pPrev = newItem;
+        if(prevItem != VMA_NULL)
+        {
+            prevItem->pNext = newItem;
+        }
+        else
+        {
+            VMA_HEAVY_ASSERT(m_pFront == pItem);
+            m_pFront = newItem;
+        }
+        ++m_Count;
+        return newItem;
+    }
+    else
+        return PushBack();
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
+{
+    if(pItem != VMA_NULL)
+    {
+        ItemType* const nextItem = pItem->pNext;
+        ItemType* const newItem = m_ItemAllocator.Alloc();
+        newItem->pNext = nextItem;
+        newItem->pPrev = pItem;
+        pItem->pNext = newItem;
+        if(nextItem != VMA_NULL)
+        {
+            nextItem->pPrev = newItem;
+        }
+        else
+        {
+            VMA_HEAVY_ASSERT(m_pBack == pItem);
+            m_pBack = newItem;
+        }
+        ++m_Count;
+        return newItem;
+    }
+    else
+        return PushFront();
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
+{
+    ItemType* const newItem = InsertBefore(pItem);
+    newItem->Value = value;
+    return newItem;
+}
+
+template<typename T>
+VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
+{
+    ItemType* const newItem = InsertAfter(pItem);
+    newItem->Value = value;
+    return newItem;
+}
+#endif // _VMA_RAW_LIST_FUNCTIONS
+#endif // _VMA_RAW_LIST
+
+#ifndef _VMA_LIST
+template<typename T, typename AllocatorT>
+class VmaList
+{
+    VMA_CLASS_NO_COPY(VmaList)
+public:
+    class reverse_iterator;
+    class const_iterator;
+    class const_reverse_iterator;
+
+    class iterator
+    {
+        friend class const_iterator;
+        friend class VmaList<T, AllocatorT>;
+    public:
+        iterator() :  m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
+        iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
+        T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }
+
+        bool operator==(const iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
+        bool operator!=(const iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
+
+        iterator operator++(int) { iterator result = *this; ++*this; return result; }
+        iterator operator--(int) { iterator result = *this; --*this; return result; }
+
+        iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pNext; return *this; }
+        iterator& operator--();
+
+    private:
+        VmaRawList<T>* m_pList;
+        VmaListItem<T>* m_pItem;
+
+        iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) : m_pList(pList),  m_pItem(pItem) {}
+    };
+    class reverse_iterator
+    {
+        friend class const_reverse_iterator;
+        friend class VmaList<T, AllocatorT>;
+    public:
+        reverse_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
+        reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
+        T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }
+
+        bool operator==(const reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
+        bool operator!=(const reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
+
+        reverse_iterator operator++(int) { reverse_iterator result = *this; ++* this; return result; }
+        reverse_iterator operator--(int) { reverse_iterator result = *this; --* this; return result; }
+
+        reverse_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pPrev; return *this; }
+        reverse_iterator& operator--();
+
+    private:
+        VmaRawList<T>* m_pList;
+        VmaListItem<T>* m_pItem;
+
+        reverse_iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) : m_pList(pList),  m_pItem(pItem) {}
+    };
+    class const_iterator
+    {
+        friend class VmaList<T, AllocatorT>;
+    public:
+        const_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
+        const_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+        const_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        iterator drop_const() { return { const_cast<VmaRawList<T>*>(m_pList), const_cast<VmaListItem<T>*>(m_pItem) }; }
+
+        const T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
+        const T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }
+
+        bool operator==(const const_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
+        bool operator!=(const const_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
+
+        const_iterator operator++(int) { const_iterator result = *this; ++* this; return result; }
+        const_iterator operator--(int) { const_iterator result = *this; --* this; return result; }
+
+        const_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pNext; return *this; }
+        const_iterator& operator--();
+
+    private:
+        const VmaRawList<T>* m_pList;
+        const VmaListItem<T>* m_pItem;
+
+        const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) : m_pList(pList), m_pItem(pItem) {}
+    };
+    class const_reverse_iterator
+    {
+        friend class VmaList<T, AllocatorT>;
+    public:
+        const_reverse_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
+        const_reverse_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+        const_reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+
+        reverse_iterator drop_const() { return { const_cast<VmaRawList<T>*>(m_pList), const_cast<VmaListItem<T>*>(m_pItem) }; }
+
+        const T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
+        const T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }
+
+        bool operator==(const const_reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
+        bool operator!=(const const_reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
+
+        const_reverse_iterator operator++(int) { const_reverse_iterator result = *this; ++* this; return result; }
+        const_reverse_iterator operator--(int) { const_reverse_iterator result = *this; --* this; return result; }
+
+        const_reverse_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pPrev; return *this; }
+        const_reverse_iterator& operator--();
+
+    private:
+        const VmaRawList<T>* m_pList;
+        const VmaListItem<T>* m_pItem;
+
+        const_reverse_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) : m_pList(pList), m_pItem(pItem) {}
+    };
+
+    VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) {}
+
+    bool empty() const { return m_RawList.IsEmpty(); }
+    size_t size() const { return m_RawList.GetCount(); }
+
+    iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
+    iterator end() { return iterator(&m_RawList, VMA_NULL); }
+
+    const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
+    const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
+
+    const_iterator begin() const { return cbegin(); }
+    const_iterator end() const { return cend(); }
+
+    reverse_iterator rbegin() { return reverse_iterator(&m_RawList, m_RawList.Back()); }
+    reverse_iterator rend() { return reverse_iterator(&m_RawList, VMA_NULL); }
+
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(&m_RawList, m_RawList.Back()); }
+    const_reverse_iterator crend() const { return const_reverse_iterator(&m_RawList, VMA_NULL); }
+
+    const_reverse_iterator rbegin() const { return crbegin(); }
+    const_reverse_iterator rend() const { return crend(); }
+
+    void push_back(const T& value) { m_RawList.PushBack(value); }
+    iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
+
+    void clear() { m_RawList.Clear(); }
+    void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
+
+private:
+    VmaRawList<T> m_RawList;
+};
+
+#ifndef _VMA_LIST_FUNCTIONS
+template<typename T, typename AllocatorT>
+typename VmaList<T, AllocatorT>::iterator& VmaList<T, AllocatorT>::iterator::operator--()
+{
+    if (m_pItem != VMA_NULL)
+    {
+        m_pItem = m_pItem->pPrev;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Back();
+    }
+    return *this;
+}
+
+template<typename T, typename AllocatorT>
+typename VmaList<T, AllocatorT>::reverse_iterator& VmaList<T, AllocatorT>::reverse_iterator::operator--()
+{
+    if (m_pItem != VMA_NULL)
+    {
+        m_pItem = m_pItem->pNext;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Front();
+    }
+    return *this;
+}
+
+template<typename T, typename AllocatorT>
+typename VmaList<T, AllocatorT>::const_iterator& VmaList<T, AllocatorT>::const_iterator::operator--()
+{
+    if (m_pItem != VMA_NULL)
+    {
+        m_pItem = m_pItem->pPrev;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Back();
+    }
+    return *this;
+}
+
+template<typename T, typename AllocatorT>
+typename VmaList<T, AllocatorT>::const_reverse_iterator& VmaList<T, AllocatorT>::const_reverse_iterator::operator--()
+{
+    if (m_pItem != VMA_NULL)
+    {
+        m_pItem = m_pItem->pNext;
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
+        m_pItem = m_pList->Back();
+    }
+    return *this;
+}
+#endif // _VMA_LIST_FUNCTIONS
+#endif // _VMA_LIST
+
+#ifndef _VMA_INTRUSIVE_LINKED_LIST
+/*
+Expected interface of ItemTypeTraits:
+struct MyItemTypeTraits
+{
+    typedef MyItem ItemType;
+    static ItemType* GetPrev(const ItemType* item) { return item->myPrevPtr; }
+    static ItemType* GetNext(const ItemType* item) { return item->myNextPtr; }
+    static ItemType*& AccessPrev(ItemType* item) { return item->myPrevPtr; }
+    static ItemType*& AccessNext(ItemType* item) { return item->myNextPtr; }
+};
+*/
+template<typename ItemTypeTraits>
+class VmaIntrusiveLinkedList
+{
+public:
+    typedef typename ItemTypeTraits::ItemType ItemType;
+    static ItemType* GetPrev(const ItemType* item) { return ItemTypeTraits::GetPrev(item); }
+    static ItemType* GetNext(const ItemType* item) { return ItemTypeTraits::GetNext(item); }
+
+    // Movable, not copyable.
+    VmaIntrusiveLinkedList() = default;
+    VmaIntrusiveLinkedList(VmaIntrusiveLinkedList && src);
+    VmaIntrusiveLinkedList(const VmaIntrusiveLinkedList&) = delete;
+    VmaIntrusiveLinkedList& operator=(VmaIntrusiveLinkedList&& src);
+    VmaIntrusiveLinkedList& operator=(const VmaIntrusiveLinkedList&) = delete;
+    ~VmaIntrusiveLinkedList() { VMA_HEAVY_ASSERT(IsEmpty()); }
+    
+    size_t GetCount() const { return m_Count; }
+    bool IsEmpty() const { return m_Count == 0; }
+    ItemType* Front() { return m_Front; }
+    ItemType* Back() { return m_Back; }
+    const ItemType* Front() const { return m_Front; }
+    const ItemType* Back() const { return m_Back; }
+
+    void PushBack(ItemType* item);
+    void PushFront(ItemType* item);
+    ItemType* PopBack();
+    ItemType* PopFront();
+
+    // MyItem can be null - it means PushBack.
+    void InsertBefore(ItemType* existingItem, ItemType* newItem);
+    // MyItem can be null - it means PushFront.
+    void InsertAfter(ItemType* existingItem, ItemType* newItem);
+    void Remove(ItemType* item);
+    void RemoveAll();
+
+private:
+    ItemType* m_Front = VMA_NULL;
+    ItemType* m_Back = VMA_NULL;
+    size_t m_Count = 0;
+};
+
+#ifndef _VMA_INTRUSIVE_LINKED_LIST_FUNCTIONS
+template<typename ItemTypeTraits>
+VmaIntrusiveLinkedList<ItemTypeTraits>::VmaIntrusiveLinkedList(VmaIntrusiveLinkedList&& src)
+    : m_Front(src.m_Front), m_Back(src.m_Back), m_Count(src.m_Count)
+{
+    src.m_Front = src.m_Back = VMA_NULL;
+    src.m_Count = 0;
+}
+
+template<typename ItemTypeTraits>
+VmaIntrusiveLinkedList<ItemTypeTraits>& VmaIntrusiveLinkedList<ItemTypeTraits>::operator=(VmaIntrusiveLinkedList&& src)
+{
+    if (&src != this)
+    {
+        VMA_HEAVY_ASSERT(IsEmpty());
+        m_Front = src.m_Front;
+        m_Back = src.m_Back;
+        m_Count = src.m_Count;
+        src.m_Front = src.m_Back = VMA_NULL;
+        src.m_Count = 0;
+    }
+    return *this;
+}
+
+template<typename ItemTypeTraits>
+void VmaIntrusiveLinkedList<ItemTypeTraits>::PushBack(ItemType* item)
+{
+    VMA_HEAVY_ASSERT(ItemTypeTraits::GetPrev(item) == VMA_NULL && ItemTypeTraits::GetNext(item) == VMA_NULL);
+    if (IsEmpty())
+    {
+        m_Front = item;
+        m_Back = item;
+        m_Count = 1;
+    }
+    else
+    {
+        ItemTypeTraits::AccessPrev(item) = m_Back;
+        ItemTypeTraits::AccessNext(m_Back) = item;
+        m_Back = item;
+        ++m_Count;
+    }
+}
+
+template<typename ItemTypeTraits>
+void VmaIntrusiveLinkedList<ItemTypeTraits>::PushFront(ItemType* item)
+{
+    VMA_HEAVY_ASSERT(ItemTypeTraits::GetPrev(item) == VMA_NULL && ItemTypeTraits::GetNext(item) == VMA_NULL);
+    if (IsEmpty())
+    {
+        m_Front = item;
+        m_Back = item;
+        m_Count = 1;
+    }
+    else
+    {
+        ItemTypeTraits::AccessNext(item) = m_Front;
+        ItemTypeTraits::AccessPrev(m_Front) = item;
+        m_Front = item;
+        ++m_Count;
+    }
+}
+
+template<typename ItemTypeTraits>
+typename VmaIntrusiveLinkedList<ItemTypeTraits>::ItemType* VmaIntrusiveLinkedList<ItemTypeTraits>::PopBack()
+{
+    VMA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const backItem = m_Back;
+    ItemType* const prevItem = ItemTypeTraits::GetPrev(backItem);
+    if (prevItem != VMA_NULL)
+    {
+        ItemTypeTraits::AccessNext(prevItem) = VMA_NULL;
+    }
+    m_Back = prevItem;
+    --m_Count;
+    ItemTypeTraits::AccessPrev(backItem) = VMA_NULL;
+    ItemTypeTraits::AccessNext(backItem) = VMA_NULL;
+    return backItem;
+}
+
+template<typename ItemTypeTraits>
+typename VmaIntrusiveLinkedList<ItemTypeTraits>::ItemType* VmaIntrusiveLinkedList<ItemTypeTraits>::PopFront()
+{
+    VMA_HEAVY_ASSERT(m_Count > 0);
+    ItemType* const frontItem = m_Front;
+    ItemType* const nextItem = ItemTypeTraits::GetNext(frontItem);
+    if (nextItem != VMA_NULL)
+    {
+        ItemTypeTraits::AccessPrev(nextItem) = VMA_NULL;
+    }
+    m_Front = nextItem;
+    --m_Count;
+    ItemTypeTraits::AccessPrev(frontItem) = VMA_NULL;
+    ItemTypeTraits::AccessNext(frontItem) = VMA_NULL;
+    return frontItem;
+}
+
+template<typename ItemTypeTraits>
+void VmaIntrusiveLinkedList<ItemTypeTraits>::InsertBefore(ItemType* existingItem, ItemType* newItem)
+{
+    VMA_HEAVY_ASSERT(newItem != VMA_NULL && ItemTypeTraits::GetPrev(newItem) == VMA_NULL && ItemTypeTraits::GetNext(newItem) == VMA_NULL);
+    if (existingItem != VMA_NULL)
+    {
+        ItemType* const prevItem = ItemTypeTraits::GetPrev(existingItem);
+        ItemTypeTraits::AccessPrev(newItem) = prevItem;
+        ItemTypeTraits::AccessNext(newItem) = existingItem;
+        ItemTypeTraits::AccessPrev(existingItem) = newItem;
+        if (prevItem != VMA_NULL)
+        {
+            ItemTypeTraits::AccessNext(prevItem) = newItem;
+        }
+        else
+        {
+            VMA_HEAVY_ASSERT(m_Front == existingItem);
+            m_Front = newItem;
+        }
+        ++m_Count;
+    }
+    else
+        PushBack(newItem);
+}
+
+template<typename ItemTypeTraits>
+void VmaIntrusiveLinkedList<ItemTypeTraits>::InsertAfter(ItemType* existingItem, ItemType* newItem)
+{
+    VMA_HEAVY_ASSERT(newItem != VMA_NULL && ItemTypeTraits::GetPrev(newItem) == VMA_NULL && ItemTypeTraits::GetNext(newItem) == VMA_NULL);
+    if (existingItem != VMA_NULL)
+    {
+        ItemType* const nextItem = ItemTypeTraits::GetNext(existingItem);
+        ItemTypeTraits::AccessNext(newItem) = nextItem;
+        ItemTypeTraits::AccessPrev(newItem) = existingItem;
+        ItemTypeTraits::AccessNext(existingItem) = newItem;
+        if (nextItem != VMA_NULL)
+        {
+            ItemTypeTraits::AccessPrev(nextItem) = newItem;
+        }
+        else
+        {
+            VMA_HEAVY_ASSERT(m_Back == existingItem);
+            m_Back = newItem;
+        }
+        ++m_Count;
+    }
+    else
+        return PushFront(newItem);
+}
+
+template<typename ItemTypeTraits>
+void VmaIntrusiveLinkedList<ItemTypeTraits>::Remove(ItemType* item)
+{
+    VMA_HEAVY_ASSERT(item != VMA_NULL && m_Count > 0);
+    if (ItemTypeTraits::GetPrev(item) != VMA_NULL)
+    {
+        ItemTypeTraits::AccessNext(ItemTypeTraits::AccessPrev(item)) = ItemTypeTraits::GetNext(item);
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(m_Front == item);
+        m_Front = ItemTypeTraits::GetNext(item);
+    }
+
+    if (ItemTypeTraits::GetNext(item) != VMA_NULL)
+    {
+        ItemTypeTraits::AccessPrev(ItemTypeTraits::AccessNext(item)) = ItemTypeTraits::GetPrev(item);
+    }
+    else
+    {
+        VMA_HEAVY_ASSERT(m_Back == item);
+        m_Back = ItemTypeTraits::GetPrev(item);
+    }
+    ItemTypeTraits::AccessPrev(item) = VMA_NULL;
+    ItemTypeTraits::AccessNext(item) = VMA_NULL;
+    --m_Count;
+}
+
+template<typename ItemTypeTraits>
+void VmaIntrusiveLinkedList<ItemTypeTraits>::RemoveAll()
+{
+    if (!IsEmpty())
+    {
+        ItemType* item = m_Back;
+        while (item != VMA_NULL)
+        {
+            ItemType* const prevItem = ItemTypeTraits::AccessPrev(item);
+            ItemTypeTraits::AccessPrev(item) = VMA_NULL;
+            ItemTypeTraits::AccessNext(item) = VMA_NULL;
+            item = prevItem;
+        }
+        m_Front = VMA_NULL;
+        m_Back = VMA_NULL;
+        m_Count = 0;
+    }
+}
+#endif // _VMA_INTRUSIVE_LINKED_LIST_FUNCTIONS
+#endif // _VMA_INTRUSIVE_LINKED_LIST
+
+// Unused in this version.
+#if 0
+
+#ifndef _VMA_PAIR
+template<typename T1, typename T2>
+struct VmaPair
+{
+    T1 first;
+    T2 second;
+
+    VmaPair() : first(), second() {}
+    VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) {}
+};
+
+template<typename FirstT, typename SecondT>
+struct VmaPairFirstLess
+{
+    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
+    {
+        return lhs.first < rhs.first;
+    }
+    bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
+    {
+        return lhs.first < rhsFirst;
+    }
+};
+#endif // _VMA_PAIR
+
+#ifndef _VMA_MAP
+/* Class compatible with subset of interface of std::unordered_map.
+KeyT, ValueT must be POD because they will be stored in VmaVector.
+*/
+template<typename KeyT, typename ValueT>
+class VmaMap
+{
+public:
+    typedef VmaPair<KeyT, ValueT> PairType;
+    typedef PairType* iterator;
+
+    VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) {}
+
+    iterator begin() { return m_Vector.begin(); }
+    iterator end() { return m_Vector.end(); }
+    size_t size() { return m_Vector.size(); }
+
+    void insert(const PairType& pair);
+    iterator find(const KeyT& key);
+    void erase(iterator it);
+
+private:
+    VmaVector< PairType, VmaStlAllocator<PairType>> m_Vector;
+};
+
+#ifndef _VMA_MAP_FUNCTIONS
+template<typename KeyT, typename ValueT>
+void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
+{
+    const size_t indexToInsert = VmaBinaryFindFirstNotLess(
+        m_Vector.data(),
+        m_Vector.data() + m_Vector.size(),
+        pair,
+        VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
+    VmaVectorInsert(m_Vector, indexToInsert, pair);
+}
+
+template<typename KeyT, typename ValueT>
+VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
+{
+    PairType* it = VmaBinaryFindFirstNotLess(
+        m_Vector.data(),
+        m_Vector.data() + m_Vector.size(),
+        key,
+        VmaPairFirstLess<KeyT, ValueT>());
+    if ((it != m_Vector.end()) && (it->first == key))
+    {
+        return it;
+    }
+    else
+    {
+        return m_Vector.end();
+    }
+}
+
+template<typename KeyT, typename ValueT>
+void VmaMap<KeyT, ValueT>::erase(iterator it)
+{
+    VmaVectorRemove(m_Vector, it - m_Vector.begin());
+}
+#endif // _VMA_MAP_FUNCTIONS
+#endif // _VMA_MAP
+
+#endif // #if 0
+
+#if !defined(_VMA_STRING_BUILDER) && VMA_STATS_STRING_ENABLED
+class VmaStringBuilder
+{
+public:
+    VmaStringBuilder(const VkAllocationCallbacks* allocationCallbacks) : m_Data(VmaStlAllocator<char>(allocationCallbacks)) {}
+    ~VmaStringBuilder() = default;
+
+    size_t GetLength() const { return m_Data.size(); }
+    const char* GetData() const { return m_Data.data(); }
+    void AddNewLine() { Add('\n'); }
+    void Add(char ch) { m_Data.push_back(ch); }
+
+    void Add(const char* pStr);
+    void AddNumber(uint32_t num);
+    void AddNumber(uint64_t num);
+    void AddPointer(const void* ptr);
+
+private:
+    VmaVector<char, VmaStlAllocator<char>> m_Data;
+};
+
+#ifndef _VMA_STRING_BUILDER_FUNCTIONS
+void VmaStringBuilder::Add(const char* pStr)
+{
+    const size_t strLen = strlen(pStr);
+    if (strLen > 0)
+    {
+        const size_t oldCount = m_Data.size();
+        m_Data.resize(oldCount + strLen);
+        memcpy(m_Data.data() + oldCount, pStr, strLen);
+    }
+}
+
+void VmaStringBuilder::AddNumber(uint32_t num)
+{
+    char buf[11];
+    buf[10] = '\0';
+    char* p = &buf[10];
+    do
+    {
+        *--p = '0' + (num % 10);
+        num /= 10;
+    } while (num);
+    Add(p);
+}
+
+void VmaStringBuilder::AddNumber(uint64_t num)
+{
+    char buf[21];
+    buf[20] = '\0';
+    char* p = &buf[20];
+    do
+    {
+        *--p = '0' + (num % 10);
+        num /= 10;
+    } while (num);
+    Add(p);
+}
+
+void VmaStringBuilder::AddPointer(const void* ptr)
+{
+    char buf[21];
+    VmaPtrToStr(buf, sizeof(buf), ptr);
+    Add(buf);
+}
+#endif //_VMA_STRING_BUILDER_FUNCTIONS
+#endif // _VMA_STRING_BUILDER
+
+#if !defined(_VMA_JSON_WRITER) && VMA_STATS_STRING_ENABLED
+/*
+Allows to conveniently build a correct JSON document to be written to the
+VmaStringBuilder passed to the constructor.
+*/
+class VmaJsonWriter
+{
+    VMA_CLASS_NO_COPY(VmaJsonWriter)
+public:
+    // sb - string builder to write the document to. Must remain alive for the whole lifetime of this object.
+    VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
+    ~VmaJsonWriter();
+
+    // Begins object by writing "{".
+    // Inside an object, you must call pairs of WriteString and a value, e.g.:
+    // j.BeginObject(true); j.WriteString("A"); j.WriteNumber(1); j.WriteString("B"); j.WriteNumber(2); j.EndObject();
+    // Will write: { "A": 1, "B": 2 }
+    void BeginObject(bool singleLine = false);
+    // Ends object by writing "}".
+    void EndObject();
+
+    // Begins array by writing "[".
+    // Inside an array, you can write a sequence of any values.
+    void BeginArray(bool singleLine = false);
+    // Ends array by writing "[".
+    void EndArray();
+
+    // Writes a string value inside "".
+    // pStr can contain any ANSI characters, including '"', new line etc. - they will be properly escaped.
+    void WriteString(const char* pStr);
+    
+    // Begins writing a string value.
+    // Call BeginString, ContinueString, ContinueString, ..., EndString instead of
+    // WriteString to conveniently build the string content incrementally, made of
+    // parts including numbers.
+    void BeginString(const char* pStr = VMA_NULL);
+    // Posts next part of an open string.
+    void ContinueString(const char* pStr);
+    // Posts next part of an open string. The number is converted to decimal characters.
+    void ContinueString(uint32_t n);
+    void ContinueString(uint64_t n);
+    void ContinueString_Size(size_t n);
+    // Posts next part of an open string. Pointer value is converted to characters
+    // using "%p" formatting - shown as hexadecimal number, e.g.: 000000081276Ad00
+    void ContinueString_Pointer(const void* ptr);
+    // Ends writing a string value by writing '"'.
+    void EndString(const char* pStr = VMA_NULL);
+
+    // Writes a number value.
+    void WriteNumber(uint32_t n);
+    void WriteNumber(uint64_t n);
+    void WriteSize(size_t n);
+    // Writes a boolean value - false or true.
+    void WriteBool(bool b);
+    // Writes a null value.
+    void WriteNull();
+
+private:
+    enum COLLECTION_TYPE
+    {
+        COLLECTION_TYPE_OBJECT,
+        COLLECTION_TYPE_ARRAY,
+    };
+    struct StackItem
+    {
+        COLLECTION_TYPE type;
+        uint32_t valueCount;
+        bool singleLineMode;
+    };
+
+    static const char* const INDENT;
+
+    VmaStringBuilder& m_SB;
+    VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
+    bool m_InsideString;
+
+    // Write size_t for less than 64bits
+    void WriteSize(size_t n, std::integral_constant<bool, false>) { m_SB.AddNumber(static_cast<uint32_t>(n)); }
+    // Write size_t for 64bits
+    void WriteSize(size_t n, std::integral_constant<bool, true>) { m_SB.AddNumber(static_cast<uint64_t>(n)); }
+
+    void BeginValue(bool isString);
+    void WriteIndent(bool oneLess = false);
+};
+const char* const VmaJsonWriter::INDENT = "  ";
+
+#ifndef _VMA_JSON_WRITER_FUNCTIONS
+VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb)
+    : m_SB(sb),
+    m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
+    m_InsideString(false) {}
+
+VmaJsonWriter::~VmaJsonWriter()
+{
+    VMA_ASSERT(!m_InsideString);
+    VMA_ASSERT(m_Stack.empty());
+}
+
+void VmaJsonWriter::BeginObject(bool singleLine)
+{
+    VMA_ASSERT(!m_InsideString);
+
+    BeginValue(false);
+    m_SB.Add('{');
+
+    StackItem item;
+    item.type = COLLECTION_TYPE_OBJECT;
+    item.valueCount = 0;
+    item.singleLineMode = singleLine;
+    m_Stack.push_back(item);
+}
+
+void VmaJsonWriter::EndObject()
+{
+    VMA_ASSERT(!m_InsideString);
+
+    WriteIndent(true);
+    m_SB.Add('}');
+
+    VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
+    m_Stack.pop_back();
+}
+
+void VmaJsonWriter::BeginArray(bool singleLine)
+{
+    VMA_ASSERT(!m_InsideString);
+
+    BeginValue(false);
+    m_SB.Add('[');
+
+    StackItem item;
+    item.type = COLLECTION_TYPE_ARRAY;
+    item.valueCount = 0;
+    item.singleLineMode = singleLine;
+    m_Stack.push_back(item);
+}
+
+void VmaJsonWriter::EndArray()
+{
+    VMA_ASSERT(!m_InsideString);
+
+    WriteIndent(true);
+    m_SB.Add(']');
+
+    VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
+    m_Stack.pop_back();
+}
+
+void VmaJsonWriter::WriteString(const char* pStr)
+{
+    BeginString(pStr);
+    EndString();
+}
+
+void VmaJsonWriter::BeginString(const char* pStr)
+{
+    VMA_ASSERT(!m_InsideString);
+
+    BeginValue(true);
+    m_SB.Add('"');
+    m_InsideString = true;
+    if (pStr != VMA_NULL && pStr[0] != '\0')
+    {
+        ContinueString(pStr);
+    }
+}
+
+void VmaJsonWriter::ContinueString(const char* pStr)
+{
+    VMA_ASSERT(m_InsideString);
+
+    const size_t strLen = strlen(pStr);
+    for (size_t i = 0; i < strLen; ++i)
+    {
+        char ch = pStr[i];
+        if (ch == '\\')
+        {
+            m_SB.Add("\\\\");
+        }
+        else if (ch == '"')
+        {
+            m_SB.Add("\\\"");
+        }
+        else if (ch >= 32)
+        {
+            m_SB.Add(ch);
+        }
+        else switch (ch)
+        {
+        case '\b':
+            m_SB.Add("\\b");
+            break;
+        case '\f':
+            m_SB.Add("\\f");
+            break;
+        case '\n':
+            m_SB.Add("\\n");
+            break;
+        case '\r':
+            m_SB.Add("\\r");
+            break;
+        case '\t':
+            m_SB.Add("\\t");
+            break;
+        default:
+            VMA_ASSERT(0 && "Character not currently supported.");
+            break;
+        }
+    }
+}
+
+void VmaJsonWriter::ContinueString(uint32_t n)
+{
+    VMA_ASSERT(m_InsideString);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::ContinueString(uint64_t n)
+{
+    VMA_ASSERT(m_InsideString);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::ContinueString_Size(size_t n)
+{
+    VMA_ASSERT(m_InsideString);
+    // Fix for AppleClang incorrect type casting
+    // TODO: Change to if constexpr when C++17 used as minimal standard
+    WriteSize(n, std::is_same<size_t, uint64_t>{});
+}
+
+void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
+{
+    VMA_ASSERT(m_InsideString);
+    m_SB.AddPointer(ptr);
+}
+
+void VmaJsonWriter::EndString(const char* pStr)
+{
+    VMA_ASSERT(m_InsideString);
+    if (pStr != VMA_NULL && pStr[0] != '\0')
+    {
+        ContinueString(pStr);
+    }
+    m_SB.Add('"');
+    m_InsideString = false;
+}
+
+void VmaJsonWriter::WriteNumber(uint32_t n)
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::WriteNumber(uint64_t n)
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.AddNumber(n);
+}
+
+void VmaJsonWriter::WriteSize(size_t n)
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    // Fix for AppleClang incorrect type casting
+    // TODO: Change to if constexpr when C++17 used as minimal standard
+    WriteSize(n, std::is_same<size_t, uint64_t>{});
+}
+
+void VmaJsonWriter::WriteBool(bool b)
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.Add(b ? "true" : "false");
+}
+
+void VmaJsonWriter::WriteNull()
+{
+    VMA_ASSERT(!m_InsideString);
+    BeginValue(false);
+    m_SB.Add("null");
+}
+
+void VmaJsonWriter::BeginValue(bool isString)
+{
+    if (!m_Stack.empty())
+    {
+        StackItem& currItem = m_Stack.back();
+        if (currItem.type == COLLECTION_TYPE_OBJECT &&
+            currItem.valueCount % 2 == 0)
+        {
+            VMA_ASSERT(isString);
+        }
+
+        if (currItem.type == COLLECTION_TYPE_OBJECT &&
+            currItem.valueCount % 2 != 0)
+        {
+            m_SB.Add(": ");
+        }
+        else if (currItem.valueCount > 0)
+        {
+            m_SB.Add(", ");
+            WriteIndent();
+        }
+        else
+        {
+            WriteIndent();
+        }
+        ++currItem.valueCount;
+    }
+}
+
+void VmaJsonWriter::WriteIndent(bool oneLess)
+{
+    if (!m_Stack.empty() && !m_Stack.back().singleLineMode)
+    {
+        m_SB.AddNewLine();
+
+        size_t count = m_Stack.size();
+        if (count > 0 && oneLess)
+        {
+            --count;
+        }
+        for (size_t i = 0; i < count; ++i)
+        {
+            m_SB.Add(INDENT);
+        }
+    }
+}
+#endif // _VMA_JSON_WRITER_FUNCTIONS
+
+static void VmaPrintDetailedStatistics(VmaJsonWriter& json, const VmaDetailedStatistics& stat)
+{
+    json.BeginObject();
+
+    json.WriteString("BlockCount");
+    json.WriteNumber(stat.statistics.blockCount);
+    json.WriteString("BlockBytes");
+    json.WriteNumber(stat.statistics.blockBytes);
+    json.WriteString("AllocationCount");
+    json.WriteNumber(stat.statistics.allocationCount);
+    json.WriteString("AllocationBytes");
+    json.WriteNumber(stat.statistics.allocationBytes);
+    json.WriteString("UnusedRangeCount");
+    json.WriteNumber(stat.unusedRangeCount);
+
+    if (stat.statistics.allocationCount > 1)
+    {
+        json.WriteString("AllocationSizeMin");
+        json.WriteNumber(stat.allocationSizeMin);
+        json.WriteString("AllocationSizeMax");
+        json.WriteNumber(stat.allocationSizeMax);
+    }
+    if (stat.unusedRangeCount > 1)
+    {
+        json.WriteString("UnusedRangeSizeMin");
+        json.WriteNumber(stat.unusedRangeSizeMin);
+        json.WriteString("UnusedRangeSizeMax");
+        json.WriteNumber(stat.unusedRangeSizeMax);
+    }
+    json.EndObject();
+}
+#endif // _VMA_JSON_WRITER
+
+#ifndef _VMA_MAPPING_HYSTERESIS
+
+class VmaMappingHysteresis
+{
+    VMA_CLASS_NO_COPY(VmaMappingHysteresis)
+public:
+    VmaMappingHysteresis() = default;
+
+    uint32_t GetExtraMapping() const { return m_ExtraMapping; }
+
+    // Call when Map was called.
+    // Returns true if switched to extra +1 mapping reference count.
+    bool PostMap()
+    {
+#if VMA_MAPPING_HYSTERESIS_ENABLED
+        if(m_ExtraMapping == 0)
+        {
+            ++m_MajorCounter;
+            if(m_MajorCounter >= COUNTER_MIN_EXTRA_MAPPING)
+            {
+                m_ExtraMapping = 1;
+                m_MajorCounter = 0;
+                m_MinorCounter = 0;
+                return true;
+            }
+        }
+        else // m_ExtraMapping == 1
+            PostMinorCounter();
+#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
+        return false;
+    }
+
+    // Call when Unmap was called.
+    void PostUnmap()
+    {
+#if VMA_MAPPING_HYSTERESIS_ENABLED
+        if(m_ExtraMapping == 0)
+            ++m_MajorCounter;
+        else // m_ExtraMapping == 1
+            PostMinorCounter();
+#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
+    }
+
+    // Call when allocation was made from the memory block.
+    void PostAlloc()
+    {
+#if VMA_MAPPING_HYSTERESIS_ENABLED
+        if(m_ExtraMapping == 1)
+            ++m_MajorCounter;
+        else // m_ExtraMapping == 0
+            PostMinorCounter();
+#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
+    }
+
+    // Call when allocation was freed from the memory block.
+    // Returns true if switched to extra -1 mapping reference count.
+    bool PostFree()
+    {
+#if VMA_MAPPING_HYSTERESIS_ENABLED
+        if(m_ExtraMapping == 1)
+        {
+            ++m_MajorCounter;
+            if(m_MajorCounter >= COUNTER_MIN_EXTRA_MAPPING &&
+                m_MajorCounter > m_MinorCounter + 1)
+            {
+                m_ExtraMapping = 0;
+                m_MajorCounter = 0;
+                m_MinorCounter = 0;
+                return true;
+            }
+        }
+        else // m_ExtraMapping == 0
+            PostMinorCounter();
+#endif // #if VMA_MAPPING_HYSTERESIS_ENABLED
+        return false;
+    }
+
+private:
+    static const int32_t COUNTER_MIN_EXTRA_MAPPING = 7;
+
+    uint32_t m_MinorCounter = 0;
+    uint32_t m_MajorCounter = 0;
+    uint32_t m_ExtraMapping = 0; // 0 or 1.
+
+    void PostMinorCounter()
+    {
+        if(m_MinorCounter < m_MajorCounter)
+        {
+            ++m_MinorCounter;
+        }
+        else if(m_MajorCounter > 0)
+        {
+            --m_MajorCounter;
+            --m_MinorCounter;
+        }
+    }
+};
+
+#endif // _VMA_MAPPING_HYSTERESIS
+
+#ifndef _VMA_DEVICE_MEMORY_BLOCK
+/*
+Represents a single block of device memory (`VkDeviceMemory`) with all the
+data about its regions (aka suballocations, #VmaAllocation), assigned and free.
+
+Thread-safety:
+- Access to m_pMetadata must be externally synchronized.
+- Map, Unmap, Bind* are synchronized internally.
+*/
+class VmaDeviceMemoryBlock
+{
+    VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
+public:
+    VmaBlockMetadata* m_pMetadata;
+
+    VmaDeviceMemoryBlock(VmaAllocator hAllocator);
+    ~VmaDeviceMemoryBlock();
+
+    // Always call after construction.
+    void Init(
+        VmaAllocator hAllocator,
+        VmaPool hParentPool,
+        uint32_t newMemoryTypeIndex,
+        VkDeviceMemory newMemory,
+        VkDeviceSize newSize,
+        uint32_t id,
+        uint32_t algorithm,
+        VkDeviceSize bufferImageGranularity);
+    // Always call before destruction.
+    void Destroy(VmaAllocator allocator);
+
+    VmaPool GetParentPool() const { return m_hParentPool; }
+    VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
+    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
+    uint32_t GetId() const { return m_Id; }
+    void* GetMappedData() const { return m_pMappedData; }
+    uint32_t GetMapRefCount() const { return m_MapCount; }
+
+    // Call when allocation/free was made from m_pMetadata.
+    // Used for m_MappingHysteresis.
+    void PostAlloc() { m_MappingHysteresis.PostAlloc(); }
+    void PostFree(VmaAllocator hAllocator);
+
+    // Validates all data structures inside this object. If not valid, returns false.
+    bool Validate() const;
+    VkResult CheckCorruption(VmaAllocator hAllocator);
+
+    // ppData can be null.
+    VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
+    void Unmap(VmaAllocator hAllocator, uint32_t count);
+
+    VkResult WriteMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
+    VkResult ValidateMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
+
+    VkResult BindBufferMemory(
+        const VmaAllocator hAllocator,
+        const VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkBuffer hBuffer,
+        const void* pNext);
+    VkResult BindImageMemory(
+        const VmaAllocator hAllocator,
+        const VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkImage hImage,
+        const void* pNext);
+
+private:
+    VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
+    uint32_t m_MemoryTypeIndex;
+    uint32_t m_Id;
+    VkDeviceMemory m_hMemory;
+
+    /*
+    Protects access to m_hMemory so it is not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
+    Also protects m_MapCount, m_pMappedData.
+    Allocations, deallocations, any change in m_pMetadata is protected by parent's VmaBlockVector::m_Mutex.
+    */
+    VMA_MUTEX m_MapAndBindMutex;
+    VmaMappingHysteresis m_MappingHysteresis;
+    uint32_t m_MapCount;
+    void* m_pMappedData;
+};
+#endif // _VMA_DEVICE_MEMORY_BLOCK
+
+#ifndef _VMA_ALLOCATION_T
+struct VmaAllocation_T
+{
+    friend struct VmaDedicatedAllocationListItemTraits;
+
+    enum FLAGS
+    {
+        FLAG_PERSISTENT_MAP   = 0x01,
+        FLAG_MAPPING_ALLOWED  = 0x02,
+    };
+
+public:
+    enum ALLOCATION_TYPE
+    {
+        ALLOCATION_TYPE_NONE,
+        ALLOCATION_TYPE_BLOCK,
+        ALLOCATION_TYPE_DEDICATED,
+    };
+
+    // This struct is allocated using VmaPoolAllocator.
+    VmaAllocation_T(bool mappingAllowed);
+    ~VmaAllocation_T();
+
+    void InitBlockAllocation(
+        VmaDeviceMemoryBlock* block,
+        VmaAllocHandle allocHandle,
+        VkDeviceSize alignment,
+        VkDeviceSize size,
+        uint32_t memoryTypeIndex,
+        VmaSuballocationType suballocationType,
+        bool mapped);
+    // pMappedData not null means allocation is created with MAPPED flag.
+    void InitDedicatedAllocation(
+        VmaPool hParentPool,
+        uint32_t memoryTypeIndex,
+        VkDeviceMemory hMemory,
+        VmaSuballocationType suballocationType,
+        void* pMappedData,
+        VkDeviceSize size);
+
+    ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
+    VkDeviceSize GetAlignment() const { return m_Alignment; }
+    VkDeviceSize GetSize() const { return m_Size; }
+    void* GetUserData() const { return m_pUserData; }
+    const char* GetName() const { return m_pName; }
+    VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
+
+    VmaDeviceMemoryBlock* GetBlock() const { VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK); return m_BlockAllocation.m_Block; }
+    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
+    bool IsPersistentMap() const { return (m_Flags & FLAG_PERSISTENT_MAP) != 0; }
+    bool IsMappingAllowed() const { return (m_Flags & FLAG_MAPPING_ALLOWED) != 0; }
+
+    void SetUserData(VmaAllocator hAllocator, void* pUserData) { m_pUserData = pUserData; }
+    void SetName(VmaAllocator hAllocator, const char* pName);
+    void FreeName(VmaAllocator hAllocator);
+    uint8_t SwapBlockAllocation(VmaAllocator hAllocator, VmaAllocation allocation);
+    VmaAllocHandle GetAllocHandle() const;
+    VkDeviceSize GetOffset() const;
+    VmaPool GetParentPool() const;
+    VkDeviceMemory GetMemory() const;
+    void* GetMappedData() const;
+
+    void BlockAllocMap();
+    void BlockAllocUnmap();
+    VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
+    void DedicatedAllocUnmap(VmaAllocator hAllocator);
+
+#if VMA_STATS_STRING_ENABLED
+    uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
+
+    void InitBufferImageUsage(uint32_t bufferImageUsage);
+    void PrintParameters(class VmaJsonWriter& json) const;
+#endif
+
+private:
+    // Allocation out of VmaDeviceMemoryBlock.
+    struct BlockAllocation
+    {
+        VmaDeviceMemoryBlock* m_Block;
+        VmaAllocHandle m_AllocHandle;
+    };
+    // Allocation for an object that has its own private VkDeviceMemory.
+    struct DedicatedAllocation
+    {
+        VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
+        VkDeviceMemory m_hMemory;
+        void* m_pMappedData; // Not null means memory is mapped.
+        VmaAllocation_T* m_Prev;
+        VmaAllocation_T* m_Next;
+    };
+    union
+    {
+        // Allocation out of VmaDeviceMemoryBlock.
+        BlockAllocation m_BlockAllocation;
+        // Allocation for an object that has its own private VkDeviceMemory.
+        DedicatedAllocation m_DedicatedAllocation;
+    };
+
+    VkDeviceSize m_Alignment;
+    VkDeviceSize m_Size;
+    void* m_pUserData;
+    char* m_pName;
+    uint32_t m_MemoryTypeIndex;
+    uint8_t m_Type; // ALLOCATION_TYPE
+    uint8_t m_SuballocationType; // VmaSuballocationType
+    // Reference counter for vmaMapMemory()/vmaUnmapMemory().
+    uint8_t m_MapCount;
+    uint8_t m_Flags; // enum FLAGS
+#if VMA_STATS_STRING_ENABLED
+    uint32_t m_BufferImageUsage; // 0 if unknown.
+#endif
+};
+#endif // _VMA_ALLOCATION_T
+
+#ifndef _VMA_DEDICATED_ALLOCATION_LIST_ITEM_TRAITS
+struct VmaDedicatedAllocationListItemTraits
+{
+    typedef VmaAllocation_T ItemType;
+
+    static ItemType* GetPrev(const ItemType* item)
+    {
+        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
+        return item->m_DedicatedAllocation.m_Prev;
+    }
+    static ItemType* GetNext(const ItemType* item)
+    {
+        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
+        return item->m_DedicatedAllocation.m_Next;
+    }
+    static ItemType*& AccessPrev(ItemType* item)
+    {
+        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
+        return item->m_DedicatedAllocation.m_Prev;
+    }
+    static ItemType*& AccessNext(ItemType* item)
+    {
+        VMA_HEAVY_ASSERT(item->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
+        return item->m_DedicatedAllocation.m_Next;
+    }
+};
+#endif // _VMA_DEDICATED_ALLOCATION_LIST_ITEM_TRAITS
+
+#ifndef _VMA_DEDICATED_ALLOCATION_LIST
+/*
+Stores linked list of VmaAllocation_T objects.
+Thread-safe, synchronized internally.
+*/
+class VmaDedicatedAllocationList
+{
+public:
+    VmaDedicatedAllocationList() {}
+    ~VmaDedicatedAllocationList();
+
+    void Init(bool useMutex) { m_UseMutex = useMutex; }
+    bool Validate();
+
+    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats);
+    void AddStatistics(VmaStatistics& inoutStats);
+#if VMA_STATS_STRING_ENABLED
+    // Writes JSON array with the list of allocations.
+    void BuildStatsString(VmaJsonWriter& json);
+#endif
+
+    bool IsEmpty();
+    void Register(VmaAllocation alloc);
+    void Unregister(VmaAllocation alloc);
+
+private:
+    typedef VmaIntrusiveLinkedList<VmaDedicatedAllocationListItemTraits> DedicatedAllocationLinkedList;
+
+    bool m_UseMutex = true;
+    VMA_RW_MUTEX m_Mutex;
+    DedicatedAllocationLinkedList m_AllocationList;
+};
+
+#ifndef _VMA_DEDICATED_ALLOCATION_LIST_FUNCTIONS
+
+VmaDedicatedAllocationList::~VmaDedicatedAllocationList()
+{
+    VMA_HEAVY_ASSERT(Validate());
+
+    if (!m_AllocationList.IsEmpty())
+    {
+        VMA_ASSERT(false && "Unfreed dedicated allocations found!");
+    }
+}
+
+bool VmaDedicatedAllocationList::Validate()
+{
+    const size_t declaredCount = m_AllocationList.GetCount();
+    size_t actualCount = 0;
+    VmaMutexLockRead lock(m_Mutex, m_UseMutex);
+    for (VmaAllocation alloc = m_AllocationList.Front();
+        alloc != VMA_NULL; alloc = m_AllocationList.GetNext(alloc))
+    {
+        ++actualCount;
+    }
+    VMA_VALIDATE(actualCount == declaredCount);
+
+    return true;
+}
+
+void VmaDedicatedAllocationList::AddDetailedStatistics(VmaDetailedStatistics& inoutStats)
+{
+    for(auto* item = m_AllocationList.Front(); item != nullptr; item = DedicatedAllocationLinkedList::GetNext(item))
+    {
+        const VkDeviceSize size = item->GetSize();
+        inoutStats.statistics.blockCount++;
+        inoutStats.statistics.blockBytes += size;
+        VmaAddDetailedStatisticsAllocation(inoutStats, item->GetSize());
+    }
+}
+
+void VmaDedicatedAllocationList::AddStatistics(VmaStatistics& inoutStats)
+{
+    VmaMutexLockRead lock(m_Mutex, m_UseMutex);
+
+    const uint32_t allocCount = (uint32_t)m_AllocationList.GetCount();
+    inoutStats.blockCount += allocCount;
+    inoutStats.allocationCount += allocCount;
+
+    for(auto* item = m_AllocationList.Front(); item != nullptr; item = DedicatedAllocationLinkedList::GetNext(item))
+    {
+        const VkDeviceSize size = item->GetSize();
+        inoutStats.blockBytes += size;
+        inoutStats.allocationBytes += size;
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaDedicatedAllocationList::BuildStatsString(VmaJsonWriter& json)
+{
+    VmaMutexLockRead lock(m_Mutex, m_UseMutex);
+    json.BeginArray();
+    for (VmaAllocation alloc = m_AllocationList.Front();
+        alloc != VMA_NULL; alloc = m_AllocationList.GetNext(alloc))
+    {
+        json.BeginObject(true);
+        alloc->PrintParameters(json);
+        json.EndObject();
+    }
+    json.EndArray();
+}
+#endif // VMA_STATS_STRING_ENABLED
+
+bool VmaDedicatedAllocationList::IsEmpty()
+{
+    VmaMutexLockRead lock(m_Mutex, m_UseMutex);
+    return m_AllocationList.IsEmpty();
+}
+
+void VmaDedicatedAllocationList::Register(VmaAllocation alloc)
+{
+    VmaMutexLockWrite lock(m_Mutex, m_UseMutex);
+    m_AllocationList.PushBack(alloc);
+}
+
+void VmaDedicatedAllocationList::Unregister(VmaAllocation alloc)
+{
+    VmaMutexLockWrite lock(m_Mutex, m_UseMutex);
+    m_AllocationList.Remove(alloc);
+}
+#endif // _VMA_DEDICATED_ALLOCATION_LIST_FUNCTIONS
+#endif // _VMA_DEDICATED_ALLOCATION_LIST
+
+#ifndef _VMA_SUBALLOCATION
+/*
+Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
+allocated memory block or free.
+*/
+struct VmaSuballocation
+{
+    VkDeviceSize offset;
+    VkDeviceSize size;
+    void* userData;
+    VmaSuballocationType type;
+};
+
+// Comparator for offsets.
+struct VmaSuballocationOffsetLess
+{
+    bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
+    {
+        return lhs.offset < rhs.offset;
+    }
+};
+
+struct VmaSuballocationOffsetGreater
+{
+    bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
+    {
+        return lhs.offset > rhs.offset;
+    }
+};
+
+struct VmaSuballocationItemSizeLess
+{
+    bool operator()(const VmaSuballocationList::iterator lhs,
+        const VmaSuballocationList::iterator rhs) const
+    {
+        return lhs->size < rhs->size;
+    }
+
+    bool operator()(const VmaSuballocationList::iterator lhs,
+        VkDeviceSize rhsSize) const
+    {
+        return lhs->size < rhsSize;
+    }
+};
+#endif // _VMA_SUBALLOCATION
+
+#ifndef _VMA_ALLOCATION_REQUEST
+/*
+Parameters of planned allocation inside a VmaDeviceMemoryBlock.
+item points to a FREE suballocation.
+*/
+struct VmaAllocationRequest
+{
+    VmaAllocHandle allocHandle;
+    VkDeviceSize size;
+    VmaSuballocationList::iterator item;
+    void* customData;
+    uint64_t algorithmData;
+    VmaAllocationRequestType type;
+};
+#endif // _VMA_ALLOCATION_REQUEST
+
+#ifndef _VMA_BLOCK_METADATA
+/*
+Data structure used for bookkeeping of allocations and unused ranges of memory
+in a single VkDeviceMemory block.
+*/
+class VmaBlockMetadata
+{
+public:
+    // pAllocationCallbacks, if not null, must be owned externally - alive and unchanged for the whole lifetime of this object.
+    VmaBlockMetadata(const VkAllocationCallbacks* pAllocationCallbacks,
+        VkDeviceSize bufferImageGranularity, bool isVirtual);
+    virtual ~VmaBlockMetadata() = default;
+
+    virtual void Init(VkDeviceSize size) { m_Size = size; }
+    bool IsVirtual() const { return m_IsVirtual; }
+    VkDeviceSize GetSize() const { return m_Size; }
+
+    // Validates all data structures inside this object. If not valid, returns false.
+    virtual bool Validate() const = 0;
+    virtual size_t GetAllocationCount() const = 0;
+    virtual size_t GetFreeRegionsCount() const = 0;
+    virtual VkDeviceSize GetSumFreeSize() const = 0;
+    // Returns true if this block is empty - contains only single free suballocation.
+    virtual bool IsEmpty() const = 0;
+    virtual void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) = 0;
+    virtual VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const = 0;
+    virtual void* GetAllocationUserData(VmaAllocHandle allocHandle) const = 0;
+
+    virtual VmaAllocHandle GetAllocationListBegin() const = 0;
+    virtual VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const = 0;
+    virtual VkDeviceSize GetNextFreeRegionSize(VmaAllocHandle alloc) const = 0;
+
+    // Shouldn't modify blockCount.
+    virtual void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const = 0;
+    virtual void AddStatistics(VmaStatistics& inoutStats) const = 0;
+
+#if VMA_STATS_STRING_ENABLED
+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
+#endif
+
+    // Tries to find a place for suballocation with given parameters inside this block.
+    // If succeeded, fills pAllocationRequest and returns true.
+    // If failed, returns false.
+    virtual bool CreateAllocationRequest(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest) = 0;
+
+    virtual VkResult CheckCorruption(const void* pBlockData) = 0;
+
+    // Makes actual allocation based on request. Request must already be checked and valid.
+    virtual void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        void* userData) = 0;
+
+    // Frees suballocation assigned to given memory region.
+    virtual void Free(VmaAllocHandle allocHandle) = 0;
+
+    // Frees all allocations.
+    // Careful! Don't call it if there are VmaAllocation objects owned by userData of cleared allocations!
+    virtual void Clear() = 0;
+
+    virtual void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) = 0;
+    virtual void DebugLogAllAllocations() const = 0;
+
+protected:
+    const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }
+    VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
+    VkDeviceSize GetDebugMargin() const { return IsVirtual() ? 0 : VMA_DEBUG_MARGIN; }
+
+    void DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size, void* userData) const;
+#if VMA_STATS_STRING_ENABLED
+    // mapRefCount == UINT32_MAX means unspecified.
+    void PrintDetailedMap_Begin(class VmaJsonWriter& json,
+        VkDeviceSize unusedBytes,
+        size_t allocationCount,
+        size_t unusedRangeCount) const;
+    void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
+        VkDeviceSize offset, VkDeviceSize size, void* userData) const;
+    void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
+        VkDeviceSize offset,
+        VkDeviceSize size) const;
+    void PrintDetailedMap_End(class VmaJsonWriter& json) const;
+#endif
+
+private:
+    VkDeviceSize m_Size;
+    const VkAllocationCallbacks* m_pAllocationCallbacks;
+    const VkDeviceSize m_BufferImageGranularity;
+    const bool m_IsVirtual;
+};
+
+#ifndef _VMA_BLOCK_METADATA_FUNCTIONS
+VmaBlockMetadata::VmaBlockMetadata(const VkAllocationCallbacks* pAllocationCallbacks,
+    VkDeviceSize bufferImageGranularity, bool isVirtual)
+    : m_Size(0),
+    m_pAllocationCallbacks(pAllocationCallbacks),
+    m_BufferImageGranularity(bufferImageGranularity),
+    m_IsVirtual(isVirtual) {}
+
+void VmaBlockMetadata::DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size, void* userData) const
+{
+    if (IsVirtual())
+    {
+        VMA_DEBUG_LOG("UNFREED VIRTUAL ALLOCATION; Offset: %llu; Size: %llu; UserData: %p", offset, size, userData);
+    }
+    else
+    {
+        VMA_ASSERT(userData != VMA_NULL);
+        VmaAllocation allocation = reinterpret_cast<VmaAllocation>(userData);
+
+        userData = allocation->GetUserData();
+        const char* name = allocation->GetName();
+
+#if VMA_STATS_STRING_ENABLED
+        VMA_DEBUG_LOG("UNFREED ALLOCATION; Offset: %llu; Size: %llu; UserData: %p; Name: %s; Type: %s; Usage: %u",
+            offset, size, userData, name ? name : "vma_empty",
+            VMA_SUBALLOCATION_TYPE_NAMES[allocation->GetSuballocationType()],
+            allocation->GetBufferImageUsage());
+#else
+        VMA_DEBUG_LOG("UNFREED ALLOCATION; Offset: %llu; Size: %llu; UserData: %p; Name: %s; Type: %u",
+            offset, size, userData, name ? name : "vma_empty",
+            (uint32_t)allocation->GetSuballocationType());
+#endif // VMA_STATS_STRING_ENABLED
+    }
+    
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
+    VkDeviceSize unusedBytes, size_t allocationCount, size_t unusedRangeCount) const
+{
+    json.WriteString("TotalBytes");
+    json.WriteNumber(GetSize());
+
+    json.WriteString("UnusedBytes");
+    json.WriteSize(unusedBytes);
+
+    json.WriteString("Allocations");
+    json.WriteSize(allocationCount);
+
+    json.WriteString("UnusedRanges");
+    json.WriteSize(unusedRangeCount);
+
+    json.WriteString("Suballocations");
+    json.BeginArray();
+}
+
+void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
+    VkDeviceSize offset, VkDeviceSize size, void* userData) const
+{
+    json.BeginObject(true);
+
+    json.WriteString("Offset");
+    json.WriteNumber(offset);
+
+    if (IsVirtual())
+    {
+        json.WriteString("Size");
+        json.WriteNumber(size);
+        if (userData)
+        {
+            json.WriteString("CustomData");
+            json.BeginString();
+            json.ContinueString_Pointer(userData);
+            json.EndString();
+        }
+    }
+    else
+    {
+        ((VmaAllocation)userData)->PrintParameters(json);
+    }
+
+    json.EndObject();
+}
+
+void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
+    VkDeviceSize offset, VkDeviceSize size) const
+{
+    json.BeginObject(true);
+
+    json.WriteString("Offset");
+    json.WriteNumber(offset);
+
+    json.WriteString("Type");
+    json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
+
+    json.WriteString("Size");
+    json.WriteNumber(size);
+
+    json.EndObject();
+}
+
+void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
+{
+    json.EndArray();
+}
+#endif // VMA_STATS_STRING_ENABLED
+#endif // _VMA_BLOCK_METADATA_FUNCTIONS
+#endif // _VMA_BLOCK_METADATA
+
+#ifndef _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY
+// Before deleting object of this class remember to call 'Destroy()'
+class VmaBlockBufferImageGranularity final
+{
+public:
+    struct ValidationContext
+    {
+        const VkAllocationCallbacks* allocCallbacks;
+        uint16_t* pageAllocs;
+    };
+
+    VmaBlockBufferImageGranularity(VkDeviceSize bufferImageGranularity);
+    ~VmaBlockBufferImageGranularity();
+
+    bool IsEnabled() const { return m_BufferImageGranularity > MAX_LOW_BUFFER_IMAGE_GRANULARITY; }
+
+    void Init(const VkAllocationCallbacks* pAllocationCallbacks, VkDeviceSize size);
+    // Before destroying object you must call free it's memory
+    void Destroy(const VkAllocationCallbacks* pAllocationCallbacks);
+
+    void RoundupAllocRequest(VmaSuballocationType allocType,
+        VkDeviceSize& inOutAllocSize,
+        VkDeviceSize& inOutAllocAlignment) const;
+
+    bool CheckConflictAndAlignUp(VkDeviceSize& inOutAllocOffset,
+        VkDeviceSize allocSize,
+        VkDeviceSize blockOffset,
+        VkDeviceSize blockSize,
+        VmaSuballocationType allocType) const;
+
+    void AllocPages(uint8_t allocType, VkDeviceSize offset, VkDeviceSize size);
+    void FreePages(VkDeviceSize offset, VkDeviceSize size);
+    void Clear();
+
+    ValidationContext StartValidation(const VkAllocationCallbacks* pAllocationCallbacks,
+        bool isVirutal) const;
+    bool Validate(ValidationContext& ctx, VkDeviceSize offset, VkDeviceSize size) const;
+    bool FinishValidation(ValidationContext& ctx) const;
+
+private:
+    static const uint16_t MAX_LOW_BUFFER_IMAGE_GRANULARITY = 256;
+
+    struct RegionInfo
+    {
+        uint8_t allocType;
+        uint16_t allocCount;
+    };
+
+    VkDeviceSize m_BufferImageGranularity;
+    uint32_t m_RegionCount;
+    RegionInfo* m_RegionInfo;
+
+    uint32_t GetStartPage(VkDeviceSize offset) const { return OffsetToPageIndex(offset & ~(m_BufferImageGranularity - 1)); }
+    uint32_t GetEndPage(VkDeviceSize offset, VkDeviceSize size) const { return OffsetToPageIndex((offset + size - 1) & ~(m_BufferImageGranularity - 1)); }
+
+    uint32_t OffsetToPageIndex(VkDeviceSize offset) const;
+    void AllocPage(RegionInfo& page, uint8_t allocType);
+};
+
+#ifndef _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY_FUNCTIONS
+VmaBlockBufferImageGranularity::VmaBlockBufferImageGranularity(VkDeviceSize bufferImageGranularity)
+    : m_BufferImageGranularity(bufferImageGranularity),
+    m_RegionCount(0),
+    m_RegionInfo(VMA_NULL) {}
+
+VmaBlockBufferImageGranularity::~VmaBlockBufferImageGranularity()
+{
+    VMA_ASSERT(m_RegionInfo == VMA_NULL && "Free not called before destroying object!");
+}
+
+void VmaBlockBufferImageGranularity::Init(const VkAllocationCallbacks* pAllocationCallbacks, VkDeviceSize size)
+{
+    if (IsEnabled())
+    {
+        m_RegionCount = static_cast<uint32_t>(VmaDivideRoundingUp(size, m_BufferImageGranularity));
+        m_RegionInfo = vma_new_array(pAllocationCallbacks, RegionInfo, m_RegionCount);
+        memset(m_RegionInfo, 0, m_RegionCount * sizeof(RegionInfo));
+    }
+}
+
+void VmaBlockBufferImageGranularity::Destroy(const VkAllocationCallbacks* pAllocationCallbacks)
+{
+    if (m_RegionInfo)
+    {
+        vma_delete_array(pAllocationCallbacks, m_RegionInfo, m_RegionCount);
+        m_RegionInfo = VMA_NULL;
+    }
+}
+
+void VmaBlockBufferImageGranularity::RoundupAllocRequest(VmaSuballocationType allocType,
+    VkDeviceSize& inOutAllocSize,
+    VkDeviceSize& inOutAllocAlignment) const
+{
+    if (m_BufferImageGranularity > 1 &&
+        m_BufferImageGranularity <= MAX_LOW_BUFFER_IMAGE_GRANULARITY)
+    {
+        if (allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
+            allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
+            allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
+        {
+            inOutAllocAlignment = VMA_MAX(inOutAllocAlignment, m_BufferImageGranularity);
+            inOutAllocSize = VmaAlignUp(inOutAllocSize, m_BufferImageGranularity);
+        }
+    }
+}
+
+bool VmaBlockBufferImageGranularity::CheckConflictAndAlignUp(VkDeviceSize& inOutAllocOffset,
+    VkDeviceSize allocSize,
+    VkDeviceSize blockOffset,
+    VkDeviceSize blockSize,
+    VmaSuballocationType allocType) const
+{
+    if (IsEnabled())
+    {
+        uint32_t startPage = GetStartPage(inOutAllocOffset);
+        if (m_RegionInfo[startPage].allocCount > 0 &&
+            VmaIsBufferImageGranularityConflict(static_cast<VmaSuballocationType>(m_RegionInfo[startPage].allocType), allocType))
+        {
+            inOutAllocOffset = VmaAlignUp(inOutAllocOffset, m_BufferImageGranularity);
+            if (blockSize < allocSize + inOutAllocOffset - blockOffset)
+                return true;
+            ++startPage;
+        }
+        uint32_t endPage = GetEndPage(inOutAllocOffset, allocSize);
+        if (endPage != startPage &&
+            m_RegionInfo[endPage].allocCount > 0 &&
+            VmaIsBufferImageGranularityConflict(static_cast<VmaSuballocationType>(m_RegionInfo[endPage].allocType), allocType))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+void VmaBlockBufferImageGranularity::AllocPages(uint8_t allocType, VkDeviceSize offset, VkDeviceSize size)
+{
+    if (IsEnabled())
+    {
+        uint32_t startPage = GetStartPage(offset);
+        AllocPage(m_RegionInfo[startPage], allocType);
+
+        uint32_t endPage = GetEndPage(offset, size);
+        if (startPage != endPage)
+            AllocPage(m_RegionInfo[endPage], allocType);
+    }
+}
+
+void VmaBlockBufferImageGranularity::FreePages(VkDeviceSize offset, VkDeviceSize size)
+{
+    if (IsEnabled())
+    {
+        uint32_t startPage = GetStartPage(offset);
+        --m_RegionInfo[startPage].allocCount;
+        if (m_RegionInfo[startPage].allocCount == 0)
+            m_RegionInfo[startPage].allocType = VMA_SUBALLOCATION_TYPE_FREE;
+        uint32_t endPage = GetEndPage(offset, size);
+        if (startPage != endPage)
+        {
+            --m_RegionInfo[endPage].allocCount;
+            if (m_RegionInfo[endPage].allocCount == 0)
+                m_RegionInfo[endPage].allocType = VMA_SUBALLOCATION_TYPE_FREE;
+        }
+    }
+}
+
+void VmaBlockBufferImageGranularity::Clear()
+{
+    if (m_RegionInfo)
+        memset(m_RegionInfo, 0, m_RegionCount * sizeof(RegionInfo));
+}
+
+VmaBlockBufferImageGranularity::ValidationContext VmaBlockBufferImageGranularity::StartValidation(
+    const VkAllocationCallbacks* pAllocationCallbacks, bool isVirutal) const
+{
+    ValidationContext ctx{ pAllocationCallbacks, VMA_NULL };
+    if (!isVirutal && IsEnabled())
+    {
+        ctx.pageAllocs = vma_new_array(pAllocationCallbacks, uint16_t, m_RegionCount);
+        memset(ctx.pageAllocs, 0, m_RegionCount * sizeof(uint16_t));
+    }
+    return ctx;
+}
+
+bool VmaBlockBufferImageGranularity::Validate(ValidationContext& ctx,
+    VkDeviceSize offset, VkDeviceSize size) const
+{
+    if (IsEnabled())
+    {
+        uint32_t start = GetStartPage(offset);
+        ++ctx.pageAllocs[start];
+        VMA_VALIDATE(m_RegionInfo[start].allocCount > 0);
+
+        uint32_t end = GetEndPage(offset, size);
+        if (start != end)
+        {
+            ++ctx.pageAllocs[end];
+            VMA_VALIDATE(m_RegionInfo[end].allocCount > 0);
+        }
+    }
+    return true;
+}
+
+bool VmaBlockBufferImageGranularity::FinishValidation(ValidationContext& ctx) const
+{
+    // Check proper page structure
+    if (IsEnabled())
+    {
+        VMA_ASSERT(ctx.pageAllocs != VMA_NULL && "Validation context not initialized!");
+
+        for (uint32_t page = 0; page < m_RegionCount; ++page)
+        {
+            VMA_VALIDATE(ctx.pageAllocs[page] == m_RegionInfo[page].allocCount);
+        }
+        vma_delete_array(ctx.allocCallbacks, ctx.pageAllocs, m_RegionCount);
+        ctx.pageAllocs = VMA_NULL;
+    }
+    return true;
+}
+
+uint32_t VmaBlockBufferImageGranularity::OffsetToPageIndex(VkDeviceSize offset) const
+{
+    return static_cast<uint32_t>(offset >> VMA_BITSCAN_MSB(m_BufferImageGranularity));
+}
+
+void VmaBlockBufferImageGranularity::AllocPage(RegionInfo& page, uint8_t allocType)
+{
+    // When current alloc type is free then it can be overriden by new type
+    if (page.allocCount == 0 || (page.allocCount > 0 && page.allocType == VMA_SUBALLOCATION_TYPE_FREE))
+        page.allocType = allocType;
+
+    ++page.allocCount;
+}
+#endif // _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY_FUNCTIONS
+#endif // _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY
+
+#if 0
+#ifndef _VMA_BLOCK_METADATA_GENERIC
+class VmaBlockMetadata_Generic : public VmaBlockMetadata
+{
+    friend class VmaDefragmentationAlgorithm_Generic;
+    friend class VmaDefragmentationAlgorithm_Fast;
+    VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
+public:
+    VmaBlockMetadata_Generic(const VkAllocationCallbacks* pAllocationCallbacks,
+        VkDeviceSize bufferImageGranularity, bool isVirtual);
+    virtual ~VmaBlockMetadata_Generic() = default;
+
+    size_t GetAllocationCount() const override { return m_Suballocations.size() - m_FreeCount; }
+    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize; }
+    bool IsEmpty() const override { return (m_Suballocations.size() == 1) && (m_FreeCount == 1); }
+    void Free(VmaAllocHandle allocHandle) override { FreeSuballocation(FindAtOffset((VkDeviceSize)allocHandle - 1)); }
+    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; };
+
+    void Init(VkDeviceSize size) override;
+    bool Validate() const override;
+
+    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
+    void AddStatistics(VmaStatistics& inoutStats) const override;
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const override;
+#endif
+
+    bool CreateAllocationRequest(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest) override;
+
+    VkResult CheckCorruption(const void* pBlockData) override;
+
+    void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        void* userData) override;
+
+    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
+    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
+    VmaAllocHandle GetAllocationListBegin() const override;
+    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
+    void Clear() override;
+    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
+    void DebugLogAllAllocations() const override;
+
+private:
+    uint32_t m_FreeCount;
+    VkDeviceSize m_SumFreeSize;
+    VmaSuballocationList m_Suballocations;
+    // Suballocations that are free. Sorted by size, ascending.
+    VmaVector<VmaSuballocationList::iterator, VmaStlAllocator<VmaSuballocationList::iterator>> m_FreeSuballocationsBySize;
+
+    VkDeviceSize AlignAllocationSize(VkDeviceSize size) const { return IsVirtual() ? size : VmaAlignUp(size, (VkDeviceSize)16); }
+
+    VmaSuballocationList::iterator FindAtOffset(VkDeviceSize offset) const;
+    bool ValidateFreeSuballocationList() const;
+
+    // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
+    // If yes, fills pOffset and returns true. If no, returns false.
+    bool CheckAllocation(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        VmaSuballocationType allocType,
+        VmaSuballocationList::const_iterator suballocItem,
+        VmaAllocHandle* pAllocHandle) const;
+
+    // Given free suballocation, it merges it with following one, which must also be free.
+    void MergeFreeWithNext(VmaSuballocationList::iterator item);
+    // Releases given suballocation, making it free.
+    // Merges it with adjacent free suballocations if applicable.
+    // Returns iterator to new free suballocation at this place.
+    VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
+    // Given free suballocation, it inserts it into sorted list of
+    // m_FreeSuballocationsBySize if it is suitable.
+    void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
+    // Given free suballocation, it removes it from sorted list of
+    // m_FreeSuballocationsBySize if it is suitable.
+    void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
+};
+
+#ifndef _VMA_BLOCK_METADATA_GENERIC_FUNCTIONS
+VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(const VkAllocationCallbacks* pAllocationCallbacks,
+    VkDeviceSize bufferImageGranularity, bool isVirtual)
+    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
+    m_FreeCount(0),
+    m_SumFreeSize(0),
+    m_Suballocations(VmaStlAllocator<VmaSuballocation>(pAllocationCallbacks)),
+    m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(pAllocationCallbacks)) {}
+
+void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
+{
+    VmaBlockMetadata::Init(size);
+
+    m_FreeCount = 1;
+    m_SumFreeSize = size;
+
+    VmaSuballocation suballoc = {};
+    suballoc.offset = 0;
+    suballoc.size = size;
+    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+
+    m_Suballocations.push_back(suballoc);
+    m_FreeSuballocationsBySize.push_back(m_Suballocations.begin());
+}
+
+bool VmaBlockMetadata_Generic::Validate() const
+{
+    VMA_VALIDATE(!m_Suballocations.empty());
+
+    // Expected offset of new suballocation as calculated from previous ones.
+    VkDeviceSize calculatedOffset = 0;
+    // Expected number of free suballocations as calculated from traversing their list.
+    uint32_t calculatedFreeCount = 0;
+    // Expected sum size of free suballocations as calculated from traversing their list.
+    VkDeviceSize calculatedSumFreeSize = 0;
+    // Expected number of free suballocations that should be registered in
+    // m_FreeSuballocationsBySize calculated from traversing their list.
+    size_t freeSuballocationsToRegister = 0;
+    // True if previous visited suballocation was free.
+    bool prevFree = false;
+
+    const VkDeviceSize debugMargin = GetDebugMargin();
+
+    for (const auto& subAlloc : m_Suballocations)
+    {
+        // Actual offset of this suballocation doesn't match expected one.
+        VMA_VALIDATE(subAlloc.offset == calculatedOffset);
+
+        const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
+        // Two adjacent free suballocations are invalid. They should be merged.
+        VMA_VALIDATE(!prevFree || !currFree);
+
+        VmaAllocation alloc = (VmaAllocation)subAlloc.userData;
+        if (!IsVirtual())
+        {
+            VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
+        }
+
+        if (currFree)
+        {
+            calculatedSumFreeSize += subAlloc.size;
+            ++calculatedFreeCount;
+            ++freeSuballocationsToRegister;
+
+            // Margin required between allocations - every free space must be at least that large.
+            VMA_VALIDATE(subAlloc.size >= debugMargin);
+        }
+        else
+        {
+            if (!IsVirtual())
+            {
+                VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == subAlloc.offset + 1);
+                VMA_VALIDATE(alloc->GetSize() == subAlloc.size);
+            }
+
+            // Margin required between allocations - previous allocation must be free.
+            VMA_VALIDATE(debugMargin == 0 || prevFree);
+        }
+
+        calculatedOffset += subAlloc.size;
+        prevFree = currFree;
+    }
+
+    // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
+    // match expected one.
+    VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
+
+    VkDeviceSize lastSize = 0;
+    for (size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
+    {
+        VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
+
+        // Only free suballocations can be registered in m_FreeSuballocationsBySize.
+        VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
+        // They must be sorted by size ascending.
+        VMA_VALIDATE(suballocItem->size >= lastSize);
+
+        lastSize = suballocItem->size;
+    }
+
+    // Check if totals match calculated values.
+    VMA_VALIDATE(ValidateFreeSuballocationList());
+    VMA_VALIDATE(calculatedOffset == GetSize());
+    VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
+    VMA_VALIDATE(calculatedFreeCount == m_FreeCount);
+
+    return true;
+}
+
+void VmaBlockMetadata_Generic::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
+{
+    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
+    inoutStats.statistics.blockCount++;
+    inoutStats.statistics.blockBytes += GetSize();
+
+    for (const auto& suballoc : m_Suballocations)
+    {
+        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+            VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+        else
+            VmaAddDetailedStatisticsUnusedRange(inoutStats, suballoc.size);
+    }
+}
+
+void VmaBlockMetadata_Generic::AddStatistics(VmaStatistics& inoutStats) const
+{
+    inoutStats.blockCount++;
+    inoutStats.allocationCount += (uint32_t)m_Suballocations.size() - m_FreeCount;
+    inoutStats.blockBytes += GetSize();
+    inoutStats.allocationBytes += GetSize() - m_SumFreeSize;
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const
+{
+    PrintDetailedMap_Begin(json,
+        m_SumFreeSize, // unusedBytes
+        m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
+        m_FreeCount, // unusedRangeCount
+        mapRefCount);
+
+    for (const auto& suballoc : m_Suballocations)
+    {
+        if (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            PrintDetailedMap_UnusedRange(json, suballoc.offset, suballoc.size);
+        }
+        else
+        {
+            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);
+        }
+    }
+
+    PrintDetailedMap_End(json);
+}
+#endif // VMA_STATS_STRING_ENABLED
+
+bool VmaBlockMetadata_Generic::CreateAllocationRequest(
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    bool upperAddress,
+    VmaSuballocationType allocType,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(allocSize > 0);
+    VMA_ASSERT(!upperAddress);
+    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(pAllocationRequest != VMA_NULL);
+    VMA_HEAVY_ASSERT(Validate());
+
+    allocSize = AlignAllocationSize(allocSize);
+
+    pAllocationRequest->type = VmaAllocationRequestType::Normal;
+    pAllocationRequest->size = allocSize;
+
+    const VkDeviceSize debugMargin = GetDebugMargin();
+
+    // There is not enough total free space in this block to fulfill the request: Early return.
+    if (m_SumFreeSize < allocSize + debugMargin)
+    {
+        return false;
+    }
+
+    // New algorithm, efficiently searching freeSuballocationsBySize.
+    const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
+    if (freeSuballocCount > 0)
+    {
+        if (strategy == 0 ||
+            strategy == VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT)
+        {
+            // Find first free suballocation with size not less than allocSize + debugMargin.
+            VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
+                m_FreeSuballocationsBySize.data(),
+                m_FreeSuballocationsBySize.data() + freeSuballocCount,
+                allocSize + debugMargin,
+                VmaSuballocationItemSizeLess());
+            size_t index = it - m_FreeSuballocationsBySize.data();
+            for (; index < freeSuballocCount; ++index)
+            {
+                if (CheckAllocation(
+                    allocSize,
+                    allocAlignment,
+                    allocType,
+                    m_FreeSuballocationsBySize[index],
+                    &pAllocationRequest->allocHandle))
+                {
+                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
+                    return true;
+                }
+            }
+        }
+        else if (strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
+        {
+            for (VmaSuballocationList::iterator it = m_Suballocations.begin();
+                it != m_Suballocations.end();
+                ++it)
+            {
+                if (it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
+                    allocSize,
+                    allocAlignment,
+                    allocType,
+                    it,
+                    &pAllocationRequest->allocHandle))
+                {
+                    pAllocationRequest->item = it;
+                    return true;
+                }
+            }
+        }
+        else
+        {
+            VMA_ASSERT(strategy & (VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT | VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT ));
+            // Search staring from biggest suballocations.
+            for (size_t index = freeSuballocCount; index--; )
+            {
+                if (CheckAllocation(
+                    allocSize,
+                    allocAlignment,
+                    allocType,
+                    m_FreeSuballocationsBySize[index],
+                    &pAllocationRequest->allocHandle))
+                {
+                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
+{
+    for (auto& suballoc : m_Suballocations)
+    {
+        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            if (!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
+                return VK_ERROR_UNKNOWN_COPY;
+            }
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaBlockMetadata_Generic::Alloc(
+    const VmaAllocationRequest& request,
+    VmaSuballocationType type,
+    void* userData)
+{
+    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
+    VMA_ASSERT(request.item != m_Suballocations.end());
+    VmaSuballocation& suballoc = *request.item;
+    // Given suballocation is a free block.
+    VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+    // Given offset is inside this suballocation.
+    VMA_ASSERT((VkDeviceSize)request.allocHandle - 1 >= suballoc.offset);
+    const VkDeviceSize paddingBegin = (VkDeviceSize)request.allocHandle - suballoc.offset - 1;
+    VMA_ASSERT(suballoc.size >= paddingBegin + request.size);
+    const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - request.size;
+
+    // Unregister this free suballocation from m_FreeSuballocationsBySize and update
+    // it to become used.
+    UnregisterFreeSuballocation(request.item);
+
+    suballoc.offset = (VkDeviceSize)request.allocHandle - 1;
+    suballoc.size = request.size;
+    suballoc.type = type;
+    suballoc.userData = userData;
+
+    // If there are any free bytes remaining at the end, insert new free suballocation after current one.
+    if (paddingEnd)
+    {
+        VmaSuballocation paddingSuballoc = {};
+        paddingSuballoc.offset = suballoc.offset + suballoc.size;
+        paddingSuballoc.size = paddingEnd;
+        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+        VmaSuballocationList::iterator next = request.item;
+        ++next;
+        const VmaSuballocationList::iterator paddingEndItem =
+            m_Suballocations.insert(next, paddingSuballoc);
+        RegisterFreeSuballocation(paddingEndItem);
+    }
+
+    // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
+    if (paddingBegin)
+    {
+        VmaSuballocation paddingSuballoc = {};
+        paddingSuballoc.offset = suballoc.offset - paddingBegin;
+        paddingSuballoc.size = paddingBegin;
+        paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+        const VmaSuballocationList::iterator paddingBeginItem =
+            m_Suballocations.insert(request.item, paddingSuballoc);
+        RegisterFreeSuballocation(paddingBeginItem);
+    }
+
+    // Update totals.
+    m_FreeCount = m_FreeCount - 1;
+    if (paddingBegin > 0)
+    {
+        ++m_FreeCount;
+    }
+    if (paddingEnd > 0)
+    {
+        ++m_FreeCount;
+    }
+    m_SumFreeSize -= request.size;
+}
+
+void VmaBlockMetadata_Generic::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
+{
+    outInfo.offset = (VkDeviceSize)allocHandle - 1;
+    const VmaSuballocation& suballoc = *FindAtOffset(outInfo.offset);
+    outInfo.size = suballoc.size;
+    outInfo.pUserData = suballoc.userData;
+}
+
+void* VmaBlockMetadata_Generic::GetAllocationUserData(VmaAllocHandle allocHandle) const
+{
+    return FindAtOffset((VkDeviceSize)allocHandle - 1)->userData;
+}
+
+VmaAllocHandle VmaBlockMetadata_Generic::GetAllocationListBegin() const
+{
+    if (IsEmpty())
+        return VK_NULL_HANDLE;
+
+    for (const auto& suballoc : m_Suballocations)
+    {
+        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+            return (VmaAllocHandle)(suballoc.offset + 1);
+    }
+    VMA_ASSERT(false && "Should contain at least 1 allocation!");
+    return VK_NULL_HANDLE;
+}
+
+VmaAllocHandle VmaBlockMetadata_Generic::GetNextAllocation(VmaAllocHandle prevAlloc) const
+{
+    VmaSuballocationList::const_iterator prev = FindAtOffset((VkDeviceSize)prevAlloc - 1);
+
+    for (VmaSuballocationList::const_iterator it = ++prev; it != m_Suballocations.end(); ++it)
+    {
+        if (it->type != VMA_SUBALLOCATION_TYPE_FREE)
+            return (VmaAllocHandle)(it->offset + 1);
+    }
+    return VK_NULL_HANDLE;
+}
+
+void VmaBlockMetadata_Generic::Clear()
+{
+    const VkDeviceSize size = GetSize();
+
+    VMA_ASSERT(IsVirtual());
+    m_FreeCount = 1;
+    m_SumFreeSize = size;
+    m_Suballocations.clear();
+    m_FreeSuballocationsBySize.clear();
+
+    VmaSuballocation suballoc = {};
+    suballoc.offset = 0;
+    suballoc.size = size;
+    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+    m_Suballocations.push_back(suballoc);
+
+    m_FreeSuballocationsBySize.push_back(m_Suballocations.begin());
+}
+
+void VmaBlockMetadata_Generic::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
+{
+    VmaSuballocation& suballoc = *FindAtOffset((VkDeviceSize)allocHandle - 1);
+    suballoc.userData = userData;
+}
+
+void VmaBlockMetadata_Generic::DebugLogAllAllocations() const
+{
+    for (const auto& suballoc : m_Suballocations)
+    {
+        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+            DebugLogAllocation(suballoc.offset, suballoc.size, suballoc.userData);
+    }
+}
+
+VmaSuballocationList::iterator VmaBlockMetadata_Generic::FindAtOffset(VkDeviceSize offset) const
+{
+    VMA_HEAVY_ASSERT(!m_Suballocations.empty());
+    const VkDeviceSize last = m_Suballocations.rbegin()->offset;
+    if (last == offset)
+        return m_Suballocations.rbegin().drop_const();
+    const VkDeviceSize first = m_Suballocations.begin()->offset;
+    if (first == offset)
+        return m_Suballocations.begin().drop_const();
+
+    const size_t suballocCount = m_Suballocations.size();
+    const VkDeviceSize step = (last - first + m_Suballocations.begin()->size) / suballocCount;
+    auto findSuballocation = [&](auto begin, auto end) -> VmaSuballocationList::iterator
+    {
+        for (auto suballocItem = begin;
+            suballocItem != end;
+            ++suballocItem)
+        {
+            if (suballocItem->offset == offset)
+                return suballocItem.drop_const();
+        }
+        VMA_ASSERT(false && "Not found!");
+        return m_Suballocations.end().drop_const();
+    };
+    // If requested offset is closer to the end of range, search from the end
+    if (offset - first > suballocCount * step / 2)
+    {
+        return findSuballocation(m_Suballocations.rbegin(), m_Suballocations.rend());
+    }
+    return findSuballocation(m_Suballocations.begin(), m_Suballocations.end());
+}
+
+bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
+{
+    VkDeviceSize lastSize = 0;
+    for (size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
+    {
+        const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
+
+        VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
+        VMA_VALIDATE(it->size >= lastSize);
+        lastSize = it->size;
+    }
+    return true;
+}
+
+bool VmaBlockMetadata_Generic::CheckAllocation(
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    VmaSuballocationType allocType,
+    VmaSuballocationList::const_iterator suballocItem,
+    VmaAllocHandle* pAllocHandle) const
+{
+    VMA_ASSERT(allocSize > 0);
+    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(suballocItem != m_Suballocations.cend());
+    VMA_ASSERT(pAllocHandle != VMA_NULL);
+
+    const VkDeviceSize debugMargin = GetDebugMargin();
+    const VkDeviceSize bufferImageGranularity = GetBufferImageGranularity();
+
+    const VmaSuballocation& suballoc = *suballocItem;
+    VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+    // Size of this suballocation is too small for this request: Early return.
+    if (suballoc.size < allocSize)
+    {
+        return false;
+    }
+
+    // Start from offset equal to beginning of this suballocation.
+    VkDeviceSize offset = suballoc.offset + (suballocItem == m_Suballocations.cbegin() ? 0 : GetDebugMargin());
+
+    // Apply debugMargin from the end of previous alloc.
+    if (debugMargin > 0)
+    {
+        offset += debugMargin;
+    }
+
+    // Apply alignment.
+    offset = VmaAlignUp(offset, allocAlignment);
+
+    // Check previous suballocations for BufferImageGranularity conflicts.
+    // Make bigger alignment if necessary.
+    if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment)
+    {
+        bool bufferImageGranularityConflict = false;
+        VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
+        while (prevSuballocItem != m_Suballocations.cbegin())
+        {
+            --prevSuballocItem;
+            const VmaSuballocation& prevSuballoc = *prevSuballocItem;
+            if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, offset, bufferImageGranularity))
+            {
+                if (VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
+                {
+                    bufferImageGranularityConflict = true;
+                    break;
+                }
+            }
+            else
+                // Already on previous page.
+                break;
+        }
+        if (bufferImageGranularityConflict)
+        {
+            offset = VmaAlignUp(offset, bufferImageGranularity);
+        }
+    }
+
+    // Calculate padding at the beginning based on current offset.
+    const VkDeviceSize paddingBegin = offset - suballoc.offset;
+
+    // Fail if requested size plus margin after is bigger than size of this suballocation.
+    if (paddingBegin + allocSize + debugMargin > suballoc.size)
+    {
+        return false;
+    }
+
+    // Check next suballocations for BufferImageGranularity conflicts.
+    // If conflict exists, allocation cannot be made here.
+    if (allocSize % bufferImageGranularity || offset % bufferImageGranularity)
+    {
+        VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
+        ++nextSuballocItem;
+        while (nextSuballocItem != m_Suballocations.cend())
+        {
+            const VmaSuballocation& nextSuballoc = *nextSuballocItem;
+            if (VmaBlocksOnSamePage(offset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+            {
+                if (VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                // Already on next page.
+                break;
+            }
+            ++nextSuballocItem;
+        }
+    }
+
+    *pAllocHandle = (VmaAllocHandle)(offset + 1);
+    // All tests passed: Success. pAllocHandle is already filled.
+    return true;
+}
+
+void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
+{
+    VMA_ASSERT(item != m_Suballocations.end());
+    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
+
+    VmaSuballocationList::iterator nextItem = item;
+    ++nextItem;
+    VMA_ASSERT(nextItem != m_Suballocations.end());
+    VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
+
+    item->size += nextItem->size;
+    --m_FreeCount;
+    m_Suballocations.erase(nextItem);
+}
+
+VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
+{
+    // Change this suballocation to be marked as free.
+    VmaSuballocation& suballoc = *suballocItem;
+    suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+    suballoc.userData = VMA_NULL;
+
+    // Update totals.
+    ++m_FreeCount;
+    m_SumFreeSize += suballoc.size;
+
+    // Merge with previous and/or next suballocation if it's also free.
+    bool mergeWithNext = false;
+    bool mergeWithPrev = false;
+
+    VmaSuballocationList::iterator nextItem = suballocItem;
+    ++nextItem;
+    if ((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
+    {
+        mergeWithNext = true;
+    }
+
+    VmaSuballocationList::iterator prevItem = suballocItem;
+    if (suballocItem != m_Suballocations.begin())
+    {
+        --prevItem;
+        if (prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            mergeWithPrev = true;
+        }
+    }
+
+    if (mergeWithNext)
+    {
+        UnregisterFreeSuballocation(nextItem);
+        MergeFreeWithNext(suballocItem);
+    }
+
+    if (mergeWithPrev)
+    {
+        UnregisterFreeSuballocation(prevItem);
+        MergeFreeWithNext(prevItem);
+        RegisterFreeSuballocation(prevItem);
+        return prevItem;
+    }
+    else
+    {
+        RegisterFreeSuballocation(suballocItem);
+        return suballocItem;
+    }
+}
+
+void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
+{
+    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(item->size > 0);
+
+    // You may want to enable this validation at the beginning or at the end of
+    // this function, depending on what do you want to check.
+    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+
+    if (m_FreeSuballocationsBySize.empty())
+    {
+        m_FreeSuballocationsBySize.push_back(item);
+    }
+    else
+    {
+        VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
+    }
+
+    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+}
+
+void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
+{
+    VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(item->size > 0);
+
+    // You may want to enable this validation at the beginning or at the end of
+    // this function, depending on what do you want to check.
+    VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+
+    VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
+        m_FreeSuballocationsBySize.data(),
+        m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
+        item,
+        VmaSuballocationItemSizeLess());
+    for (size_t index = it - m_FreeSuballocationsBySize.data();
+        index < m_FreeSuballocationsBySize.size();
+        ++index)
+    {
+        if (m_FreeSuballocationsBySize[index] == item)
+        {
+            VmaVectorRemove(m_FreeSuballocationsBySize, index);
+            return;
+        }
+        VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
+    }
+    VMA_ASSERT(0 && "Not found.");
+
+    //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
+}
+#endif // _VMA_BLOCK_METADATA_GENERIC_FUNCTIONS
+#endif // _VMA_BLOCK_METADATA_GENERIC
+#endif // #if 0
+
+#ifndef _VMA_BLOCK_METADATA_LINEAR
+/*
+Allocations and their references in internal data structure look like this:
+
+if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
+
+        0 +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount]
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  1st[1st.size() - 1]
+          +-------+
+          |       |
+          |       |
+          |       |
+GetSize() +-------+
+
+if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
+
+        0 +-------+
+          | Alloc |  2nd[0]
+          +-------+
+          | Alloc |  2nd[1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  2nd[2nd.size() - 1]
+          +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount]
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  1st[1st.size() - 1]
+          +-------+
+          |       |
+GetSize() +-------+
+
+if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
+
+        0 +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount]
+          +-------+
+          | Alloc |  1st[m_1stNullItemsBeginCount + 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  1st[1st.size() - 1]
+          +-------+
+          |       |
+          |       |
+          |       |
+          +-------+
+          | Alloc |  2nd[2nd.size() - 1]
+          +-------+
+          |  ...  |
+          +-------+
+          | Alloc |  2nd[1]
+          +-------+
+          | Alloc |  2nd[0]
+GetSize() +-------+
+
+*/
+class VmaBlockMetadata_Linear : public VmaBlockMetadata
+{
+    VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
+public:
+    VmaBlockMetadata_Linear(const VkAllocationCallbacks* pAllocationCallbacks,
+        VkDeviceSize bufferImageGranularity, bool isVirtual);
+    virtual ~VmaBlockMetadata_Linear() = default;
+
+    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize; }
+    bool IsEmpty() const override { return GetAllocationCount() == 0; }
+    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; };
+
+    void Init(VkDeviceSize size) override;
+    bool Validate() const override;
+    size_t GetAllocationCount() const override;
+    size_t GetFreeRegionsCount() const override;
+
+    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
+    void AddStatistics(VmaStatistics& inoutStats) const override;
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json) const override;
+#endif
+
+    bool CreateAllocationRequest(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest) override;
+
+    VkResult CheckCorruption(const void* pBlockData) override;
+
+    void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        void* userData) override;
+
+    void Free(VmaAllocHandle allocHandle) override;
+    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
+    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
+    VmaAllocHandle GetAllocationListBegin() const override;
+    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
+    VkDeviceSize GetNextFreeRegionSize(VmaAllocHandle alloc) const override;
+    void Clear() override;
+    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
+    void DebugLogAllAllocations() const override;
+
+private:
+    /*
+    There are two suballocation vectors, used in ping-pong way.
+    The one with index m_1stVectorIndex is called 1st.
+    The one with index (m_1stVectorIndex ^ 1) is called 2nd.
+    2nd can be non-empty only when 1st is not empty.
+    When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
+    */
+    typedef VmaVector<VmaSuballocation, VmaStlAllocator<VmaSuballocation>> SuballocationVectorType;
+
+    enum SECOND_VECTOR_MODE
+    {
+        SECOND_VECTOR_EMPTY,
+        /*
+        Suballocations in 2nd vector are created later than the ones in 1st, but they
+        all have smaller offset.
+        */
+        SECOND_VECTOR_RING_BUFFER,
+        /*
+        Suballocations in 2nd vector are upper side of double stack.
+        They all have offsets higher than those in 1st vector.
+        Top of this stack means smaller offsets, but higher indices in this vector.
+        */
+        SECOND_VECTOR_DOUBLE_STACK,
+    };
+
+    VkDeviceSize m_SumFreeSize;
+    SuballocationVectorType m_Suballocations0, m_Suballocations1;
+    uint32_t m_1stVectorIndex;
+    SECOND_VECTOR_MODE m_2ndVectorMode;
+    // Number of items in 1st vector with hAllocation = null at the beginning.
+    size_t m_1stNullItemsBeginCount;
+    // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
+    size_t m_1stNullItemsMiddleCount;
+    // Number of items in 2nd vector with hAllocation = null.
+    size_t m_2ndNullItemsCount;
+
+    SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
+    SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
+    const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
+    const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
+
+    VmaSuballocation& FindSuballocation(VkDeviceSize offset) const;
+    bool ShouldCompact1st() const;
+    void CleanupAfterFree();
+
+    bool CreateAllocationRequest_LowerAddress(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        VmaSuballocationType allocType,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest);
+    bool CreateAllocationRequest_UpperAddress(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        VmaSuballocationType allocType,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest);
+};
+
+#ifndef _VMA_BLOCK_METADATA_LINEAR_FUNCTIONS
+VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(const VkAllocationCallbacks* pAllocationCallbacks,
+    VkDeviceSize bufferImageGranularity, bool isVirtual)
+    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
+    m_SumFreeSize(0),
+    m_Suballocations0(VmaStlAllocator<VmaSuballocation>(pAllocationCallbacks)),
+    m_Suballocations1(VmaStlAllocator<VmaSuballocation>(pAllocationCallbacks)),
+    m_1stVectorIndex(0),
+    m_2ndVectorMode(SECOND_VECTOR_EMPTY),
+    m_1stNullItemsBeginCount(0),
+    m_1stNullItemsMiddleCount(0),
+    m_2ndNullItemsCount(0) {}
+
+void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
+{
+    VmaBlockMetadata::Init(size);
+    m_SumFreeSize = size;
+}
+
+bool VmaBlockMetadata_Linear::Validate() const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    VMA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
+    VMA_VALIDATE(!suballocations1st.empty() ||
+        suballocations2nd.empty() ||
+        m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);
+
+    if (!suballocations1st.empty())
+    {
+        // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
+        VMA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].type != VMA_SUBALLOCATION_TYPE_FREE);
+        // Null item at the end should be just pop_back().
+        VMA_VALIDATE(suballocations1st.back().type != VMA_SUBALLOCATION_TYPE_FREE);
+    }
+    if (!suballocations2nd.empty())
+    {
+        // Null item at the end should be just pop_back().
+        VMA_VALIDATE(suballocations2nd.back().type != VMA_SUBALLOCATION_TYPE_FREE);
+    }
+
+    VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
+    VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());
+
+    VkDeviceSize sumUsedSize = 0;
+    const size_t suballoc1stCount = suballocations1st.size();
+    const VkDeviceSize debugMargin = GetDebugMargin();
+    VkDeviceSize offset = 0;
+
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const size_t suballoc2ndCount = suballocations2nd.size();
+        size_t nullItem2ndCount = 0;
+        for (size_t i = 0; i < suballoc2ndCount; ++i)
+        {
+            const VmaSuballocation& suballoc = suballocations2nd[i];
+            const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+            VmaAllocation const alloc = (VmaAllocation)suballoc.userData;
+            if (!IsVirtual())
+            {
+                VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
+            }
+            VMA_VALIDATE(suballoc.offset >= offset);
+
+            if (!currFree)
+            {
+                if (!IsVirtual())
+                {
+                    VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == suballoc.offset + 1);
+                    VMA_VALIDATE(alloc->GetSize() == suballoc.size);
+                }
+                sumUsedSize += suballoc.size;
+            }
+            else
+            {
+                ++nullItem2ndCount;
+            }
+
+            offset = suballoc.offset + suballoc.size + debugMargin;
+        }
+
+        VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
+    }
+
+    for (size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations1st[i];
+        VMA_VALIDATE(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE &&
+            suballoc.userData == VMA_NULL);
+    }
+
+    size_t nullItem1stCount = m_1stNullItemsBeginCount;
+
+    for (size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations1st[i];
+        const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+        VmaAllocation const alloc = (VmaAllocation)suballoc.userData;
+        if (!IsVirtual())
+        {
+            VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
+        }
+        VMA_VALIDATE(suballoc.offset >= offset);
+        VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);
+
+        if (!currFree)
+        {
+            if (!IsVirtual())
+            {
+                VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == suballoc.offset + 1);
+                VMA_VALIDATE(alloc->GetSize() == suballoc.size);
+            }
+            sumUsedSize += suballoc.size;
+        }
+        else
+        {
+            ++nullItem1stCount;
+        }
+
+        offset = suballoc.offset + suballoc.size + debugMargin;
+    }
+    VMA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        const size_t suballoc2ndCount = suballocations2nd.size();
+        size_t nullItem2ndCount = 0;
+        for (size_t i = suballoc2ndCount; i--; )
+        {
+            const VmaSuballocation& suballoc = suballocations2nd[i];
+            const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
+
+            VmaAllocation const alloc = (VmaAllocation)suballoc.userData;
+            if (!IsVirtual())
+            {
+                VMA_VALIDATE(currFree == (alloc == VK_NULL_HANDLE));
+            }
+            VMA_VALIDATE(suballoc.offset >= offset);
+
+            if (!currFree)
+            {
+                if (!IsVirtual())
+                {
+                    VMA_VALIDATE((VkDeviceSize)alloc->GetAllocHandle() == suballoc.offset + 1);
+                    VMA_VALIDATE(alloc->GetSize() == suballoc.size);
+                }
+                sumUsedSize += suballoc.size;
+            }
+            else
+            {
+                ++nullItem2ndCount;
+            }
+
+            offset = suballoc.offset + suballoc.size + debugMargin;
+        }
+
+        VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
+    }
+
+    VMA_VALIDATE(offset <= GetSize());
+    VMA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);
+
+    return true;
+}
+
+size_t VmaBlockMetadata_Linear::GetAllocationCount() const
+{
+    return AccessSuballocations1st().size() - m_1stNullItemsBeginCount - m_1stNullItemsMiddleCount +
+        AccessSuballocations2nd().size() - m_2ndNullItemsCount;
+}
+
+size_t VmaBlockMetadata_Linear::GetFreeRegionsCount() const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    VMA_ASSERT(0);
+    return SIZE_MAX;
+}
+
+void VmaBlockMetadata_Linear::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
+{
+    const VkDeviceSize size = GetSize();
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    inoutStats.statistics.blockCount++;
+    inoutStats.statistics.blockBytes += size;
+
+    VkDeviceSize lastOffset = 0;
+
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while (lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAllocIndex to the end.
+            while (nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                if (lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    const VkDeviceSize freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while (lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while (nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if (nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if (lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+            if (lastOffset < freeSpace1stTo2ndEnd)
+            {
+                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+                VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while (lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAllocIndex to the end.
+            while (nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                VmaAddDetailedStatisticsAllocation(inoutStats, suballoc.size);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                // There is free space from lastOffset to size.
+                if (lastOffset < size)
+                {
+                    const VkDeviceSize unusedRangeSize = size - lastOffset;
+                    VmaAddDetailedStatisticsUnusedRange(inoutStats, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+}
+
+void VmaBlockMetadata_Linear::AddStatistics(VmaStatistics& inoutStats) const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const VkDeviceSize size = GetSize();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    inoutStats.blockCount++;
+    inoutStats.blockBytes += size;
+    inoutStats.allocationBytes += size - m_SumFreeSize;
+
+    VkDeviceSize lastOffset = 0;
+
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
+        while (lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++inoutStats.allocationCount;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    const VkDeviceSize freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while (lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while (nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if (nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if (lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            ++inoutStats.allocationCount;
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if (lastOffset < freeSpace1stTo2ndEnd)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while (lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++inoutStats.allocationCount;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    const VkDeviceSize unusedRangeSize = size - lastOffset;
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
+{
+    const VkDeviceSize size = GetSize();
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    const size_t suballoc1stCount = suballocations1st.size();
+    const size_t suballoc2ndCount = suballocations2nd.size();
+
+    // FIRST PASS
+
+    size_t unusedRangeCount = 0;
+    VkDeviceSize usedBytes = 0;
+
+    VkDeviceSize lastOffset = 0;
+
+    size_t alloc2ndCount = 0;
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while (lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    ++unusedRangeCount;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++alloc2ndCount;
+                usedBytes += suballoc.size;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    ++unusedRangeCount;
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    size_t alloc1stCount = 0;
+    const VkDeviceSize freeSpace1stTo2ndEnd =
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
+    while (lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while (nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if (nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if (lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                ++unusedRangeCount;
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            ++alloc1stCount;
+            usedBytes += suballoc.size;
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if (lastOffset < size)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                ++unusedRangeCount;
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while (lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    ++unusedRangeCount;
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                ++alloc2ndCount;
+                usedBytes += suballoc.size;
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    ++unusedRangeCount;
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+
+    const VkDeviceSize unusedBytes = size - usedBytes;
+    PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
+
+    // SECOND PASS
+    lastOffset = 0;
+
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
+        size_t nextAlloc2ndIndex = 0;
+        while (lastOffset < freeSpace2ndTo1stEnd)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex < suballoc2ndCount &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                ++nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex < suballoc2ndCount)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                ++nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < freeSpace2ndTo1stEnd)
+                {
+                    // There is free space from lastOffset to freeSpace2ndTo1stEnd.
+                    const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = freeSpace2ndTo1stEnd;
+            }
+        }
+    }
+
+    nextAlloc1stIndex = m_1stNullItemsBeginCount;
+    while (lastOffset < freeSpace1stTo2ndEnd)
+    {
+        // Find next non-null allocation or move nextAllocIndex to the end.
+        while (nextAlloc1stIndex < suballoc1stCount &&
+            suballocations1st[nextAlloc1stIndex].userData == VMA_NULL)
+        {
+            ++nextAlloc1stIndex;
+        }
+
+        // Found non-null allocation.
+        if (nextAlloc1stIndex < suballoc1stCount)
+        {
+            const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
+
+            // 1. Process free space before this allocation.
+            if (lastOffset < suballoc.offset)
+            {
+                // There is free space from lastOffset to suballoc.offset.
+                const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+            }
+
+            // 2. Process this allocation.
+            // There is allocation with suballoc.offset, suballoc.size.
+            PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);
+
+            // 3. Prepare for next iteration.
+            lastOffset = suballoc.offset + suballoc.size;
+            ++nextAlloc1stIndex;
+        }
+        // We are at the end.
+        else
+        {
+            if (lastOffset < freeSpace1stTo2ndEnd)
+            {
+                // There is free space from lastOffset to freeSpace1stTo2ndEnd.
+                const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
+                PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+            }
+
+            // End of loop.
+            lastOffset = freeSpace1stTo2ndEnd;
+        }
+    }
+
+    if (m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
+        while (lastOffset < size)
+        {
+            // Find next non-null allocation or move nextAlloc2ndIndex to the end.
+            while (nextAlloc2ndIndex != SIZE_MAX &&
+                suballocations2nd[nextAlloc2ndIndex].userData == VMA_NULL)
+            {
+                --nextAlloc2ndIndex;
+            }
+
+            // Found non-null allocation.
+            if (nextAlloc2ndIndex != SIZE_MAX)
+            {
+                const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
+
+                // 1. Process free space before this allocation.
+                if (lastOffset < suballoc.offset)
+                {
+                    // There is free space from lastOffset to suballoc.offset.
+                    const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // 2. Process this allocation.
+                // There is allocation with suballoc.offset, suballoc.size.
+                PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.size, suballoc.userData);
+
+                // 3. Prepare for next iteration.
+                lastOffset = suballoc.offset + suballoc.size;
+                --nextAlloc2ndIndex;
+            }
+            // We are at the end.
+            else
+            {
+                if (lastOffset < size)
+                {
+                    // There is free space from lastOffset to size.
+                    const VkDeviceSize unusedRangeSize = size - lastOffset;
+                    PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
+                }
+
+                // End of loop.
+                lastOffset = size;
+            }
+        }
+    }
+
+    PrintDetailedMap_End(json);
+}
+#endif // VMA_STATS_STRING_ENABLED
+
+bool VmaBlockMetadata_Linear::CreateAllocationRequest(
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    bool upperAddress,
+    VmaSuballocationType allocType,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(allocSize > 0);
+    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
+    VMA_ASSERT(pAllocationRequest != VMA_NULL);
+    VMA_HEAVY_ASSERT(Validate());
+    pAllocationRequest->size = allocSize;
+    return upperAddress ?
+        CreateAllocationRequest_UpperAddress(
+            allocSize, allocAlignment, allocType, strategy, pAllocationRequest) :
+        CreateAllocationRequest_LowerAddress(
+            allocSize, allocAlignment, allocType, strategy, pAllocationRequest);
+}
+
+VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
+{
+    VMA_ASSERT(!IsVirtual());
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    for (size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations1st[i];
+        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            if (!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
+                return VK_ERROR_UNKNOWN_COPY;
+            }
+        }
+    }
+
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    for (size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
+    {
+        const VmaSuballocation& suballoc = suballocations2nd[i];
+        if (suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            if (!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
+                return VK_ERROR_UNKNOWN_COPY;
+            }
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaBlockMetadata_Linear::Alloc(
+    const VmaAllocationRequest& request,
+    VmaSuballocationType type,
+    void* userData)
+{
+    const VkDeviceSize offset = (VkDeviceSize)request.allocHandle - 1;
+    const VmaSuballocation newSuballoc = { offset, request.size, userData, type };
+
+    switch (request.type)
+    {
+    case VmaAllocationRequestType::UpperAddress:
+    {
+        VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
+            "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
+        SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+        suballocations2nd.push_back(newSuballoc);
+        m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
+    }
+    break;
+    case VmaAllocationRequestType::EndOf1st:
+    {
+        SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+
+        VMA_ASSERT(suballocations1st.empty() ||
+            offset >= suballocations1st.back().offset + suballocations1st.back().size);
+        // Check if it fits before the end of the block.
+        VMA_ASSERT(offset + request.size <= GetSize());
+
+        suballocations1st.push_back(newSuballoc);
+    }
+    break;
+    case VmaAllocationRequestType::EndOf2nd:
+    {
+        SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+        // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
+        VMA_ASSERT(!suballocations1st.empty() &&
+            offset + request.size <= suballocations1st[m_1stNullItemsBeginCount].offset);
+        SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+        switch (m_2ndVectorMode)
+        {
+        case SECOND_VECTOR_EMPTY:
+            // First allocation from second part ring buffer.
+            VMA_ASSERT(suballocations2nd.empty());
+            m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
+            break;
+        case SECOND_VECTOR_RING_BUFFER:
+            // 2-part ring buffer is already started.
+            VMA_ASSERT(!suballocations2nd.empty());
+            break;
+        case SECOND_VECTOR_DOUBLE_STACK:
+            VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
+            break;
+        default:
+            VMA_ASSERT(0);
+        }
+
+        suballocations2nd.push_back(newSuballoc);
+    }
+    break;
+    default:
+        VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
+    }
+
+    m_SumFreeSize -= newSuballoc.size;
+}
+
+void VmaBlockMetadata_Linear::Free(VmaAllocHandle allocHandle)
+{
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    VkDeviceSize offset = (VkDeviceSize)allocHandle - 1;
+
+    if (!suballocations1st.empty())
+    {
+        // First allocation: Mark it as next empty at the beginning.
+        VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
+        if (firstSuballoc.offset == offset)
+        {
+            firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
+            firstSuballoc.userData = VMA_NULL;
+            m_SumFreeSize += firstSuballoc.size;
+            ++m_1stNullItemsBeginCount;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    // Last allocation in 2-part ring buffer or top of upper stack (same logic).
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
+        m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        VmaSuballocation& lastSuballoc = suballocations2nd.back();
+        if (lastSuballoc.offset == offset)
+        {
+            m_SumFreeSize += lastSuballoc.size;
+            suballocations2nd.pop_back();
+            CleanupAfterFree();
+            return;
+        }
+    }
+    // Last allocation in 1st vector.
+    else if (m_2ndVectorMode == SECOND_VECTOR_EMPTY)
+    {
+        VmaSuballocation& lastSuballoc = suballocations1st.back();
+        if (lastSuballoc.offset == offset)
+        {
+            m_SumFreeSize += lastSuballoc.size;
+            suballocations1st.pop_back();
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    VmaSuballocation refSuballoc;
+    refSuballoc.offset = offset;
+    // Rest of members stays uninitialized intentionally for better performance.
+
+    // Item from the middle of 1st vector.
+    {
+        const SuballocationVectorType::iterator it = VmaBinaryFindSorted(
+            suballocations1st.begin() + m_1stNullItemsBeginCount,
+            suballocations1st.end(),
+            refSuballoc,
+            VmaSuballocationOffsetLess());
+        if (it != suballocations1st.end())
+        {
+            it->type = VMA_SUBALLOCATION_TYPE_FREE;
+            it->userData = VMA_NULL;
+            ++m_1stNullItemsMiddleCount;
+            m_SumFreeSize += it->size;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    if (m_2ndVectorMode != SECOND_VECTOR_EMPTY)
+    {
+        // Item from the middle of 2nd vector.
+        const SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
+            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
+            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
+        if (it != suballocations2nd.end())
+        {
+            it->type = VMA_SUBALLOCATION_TYPE_FREE;
+            it->userData = VMA_NULL;
+            ++m_2ndNullItemsCount;
+            m_SumFreeSize += it->size;
+            CleanupAfterFree();
+            return;
+        }
+    }
+
+    VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
+}
+
+void VmaBlockMetadata_Linear::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
+{
+    outInfo.offset = (VkDeviceSize)allocHandle - 1;
+    VmaSuballocation& suballoc = FindSuballocation(outInfo.offset);
+    outInfo.size = suballoc.size;
+    outInfo.pUserData = suballoc.userData;
+}
+
+void* VmaBlockMetadata_Linear::GetAllocationUserData(VmaAllocHandle allocHandle) const
+{
+    return FindSuballocation((VkDeviceSize)allocHandle - 1).userData;
+}
+
+VmaAllocHandle VmaBlockMetadata_Linear::GetAllocationListBegin() const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    VMA_ASSERT(0);
+    return VK_NULL_HANDLE;
+}
+
+VmaAllocHandle VmaBlockMetadata_Linear::GetNextAllocation(VmaAllocHandle prevAlloc) const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    VMA_ASSERT(0);
+    return VK_NULL_HANDLE;
+}
+
+VkDeviceSize VmaBlockMetadata_Linear::GetNextFreeRegionSize(VmaAllocHandle alloc) const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    VMA_ASSERT(0);
+    return 0;
+}
+
+void VmaBlockMetadata_Linear::Clear()
+{
+    m_SumFreeSize = GetSize();
+    m_Suballocations0.clear();
+    m_Suballocations1.clear();
+    // Leaving m_1stVectorIndex unchanged - it doesn't matter.
+    m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+    m_1stNullItemsBeginCount = 0;
+    m_1stNullItemsMiddleCount = 0;
+    m_2ndNullItemsCount = 0;
+}
+
+void VmaBlockMetadata_Linear::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
+{
+    VmaSuballocation& suballoc = FindSuballocation((VkDeviceSize)allocHandle - 1);
+    suballoc.userData = userData;
+}
+
+void VmaBlockMetadata_Linear::DebugLogAllAllocations() const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    for (auto it = suballocations1st.begin() + m_1stNullItemsBeginCount; it != suballocations1st.end(); ++it)
+        if (it->type != VMA_SUBALLOCATION_TYPE_FREE)
+            DebugLogAllocation(it->offset, it->size, it->userData);
+
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+    for (auto it = suballocations2nd.begin(); it != suballocations2nd.end(); ++it)
+        if (it->type != VMA_SUBALLOCATION_TYPE_FREE)
+            DebugLogAllocation(it->offset, it->size, it->userData);
+}
+
+VmaSuballocation& VmaBlockMetadata_Linear::FindSuballocation(VkDeviceSize offset) const
+{
+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    VmaSuballocation refSuballoc;
+    refSuballoc.offset = offset;
+    // Rest of members stays uninitialized intentionally for better performance.
+
+    // Item from the 1st vector.
+    {
+        SuballocationVectorType::const_iterator it = VmaBinaryFindSorted(
+            suballocations1st.begin() + m_1stNullItemsBeginCount,
+            suballocations1st.end(),
+            refSuballoc,
+            VmaSuballocationOffsetLess());
+        if (it != suballocations1st.end())
+        {
+            return const_cast<VmaSuballocation&>(*it);
+        }
+    }
+
+    if (m_2ndVectorMode != SECOND_VECTOR_EMPTY)
+    {
+        // Rest of members stays uninitialized intentionally for better performance.
+        SuballocationVectorType::const_iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
+            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
+            VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
+        if (it != suballocations2nd.end())
+        {
+            return const_cast<VmaSuballocation&>(*it);
+        }
+    }
+
+    VMA_ASSERT(0 && "Allocation not found in linear allocator!");
+    return const_cast<VmaSuballocation&>(suballocations1st.back()); // Should never occur.
+}
+
+bool VmaBlockMetadata_Linear::ShouldCompact1st() const
+{
+    const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
+    const size_t suballocCount = AccessSuballocations1st().size();
+    return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
+}
+
+void VmaBlockMetadata_Linear::CleanupAfterFree()
+{
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if (IsEmpty())
+    {
+        suballocations1st.clear();
+        suballocations2nd.clear();
+        m_1stNullItemsBeginCount = 0;
+        m_1stNullItemsMiddleCount = 0;
+        m_2ndNullItemsCount = 0;
+        m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+    }
+    else
+    {
+        const size_t suballoc1stCount = suballocations1st.size();
+        const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
+        VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
+
+        // Find more null items at the beginning of 1st vector.
+        while (m_1stNullItemsBeginCount < suballoc1stCount &&
+            suballocations1st[m_1stNullItemsBeginCount].type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            ++m_1stNullItemsBeginCount;
+            --m_1stNullItemsMiddleCount;
+        }
+
+        // Find more null items at the end of 1st vector.
+        while (m_1stNullItemsMiddleCount > 0 &&
+            suballocations1st.back().type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            --m_1stNullItemsMiddleCount;
+            suballocations1st.pop_back();
+        }
+
+        // Find more null items at the end of 2nd vector.
+        while (m_2ndNullItemsCount > 0 &&
+            suballocations2nd.back().type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            --m_2ndNullItemsCount;
+            suballocations2nd.pop_back();
+        }
+
+        // Find more null items at the beginning of 2nd vector.
+        while (m_2ndNullItemsCount > 0 &&
+            suballocations2nd[0].type == VMA_SUBALLOCATION_TYPE_FREE)
+        {
+            --m_2ndNullItemsCount;
+            VmaVectorRemove(suballocations2nd, 0);
+        }
+
+        if (ShouldCompact1st())
+        {
+            const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
+            size_t srcIndex = m_1stNullItemsBeginCount;
+            for (size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
+            {
+                while (suballocations1st[srcIndex].type == VMA_SUBALLOCATION_TYPE_FREE)
+                {
+                    ++srcIndex;
+                }
+                if (dstIndex != srcIndex)
+                {
+                    suballocations1st[dstIndex] = suballocations1st[srcIndex];
+                }
+                ++srcIndex;
+            }
+            suballocations1st.resize(nonNullItemCount);
+            m_1stNullItemsBeginCount = 0;
+            m_1stNullItemsMiddleCount = 0;
+        }
+
+        // 2nd vector became empty.
+        if (suballocations2nd.empty())
+        {
+            m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+        }
+
+        // 1st vector became empty.
+        if (suballocations1st.size() - m_1stNullItemsBeginCount == 0)
+        {
+            suballocations1st.clear();
+            m_1stNullItemsBeginCount = 0;
+
+            if (!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+            {
+                // Swap 1st with 2nd. Now 2nd is empty.
+                m_2ndVectorMode = SECOND_VECTOR_EMPTY;
+                m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
+                while (m_1stNullItemsBeginCount < suballocations2nd.size() &&
+                    suballocations2nd[m_1stNullItemsBeginCount].type == VMA_SUBALLOCATION_TYPE_FREE)
+                {
+                    ++m_1stNullItemsBeginCount;
+                    --m_1stNullItemsMiddleCount;
+                }
+                m_2ndNullItemsCount = 0;
+                m_1stVectorIndex ^= 1;
+            }
+        }
+    }
+
+    VMA_HEAVY_ASSERT(Validate());
+}
+
+bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    VmaSuballocationType allocType,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    const VkDeviceSize blockSize = GetSize();
+    const VkDeviceSize debugMargin = GetDebugMargin();
+    const VkDeviceSize bufferImageGranularity = GetBufferImageGranularity();
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if (m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+    {
+        // Try to allocate at the end of 1st vector.
+
+        VkDeviceSize resultBaseOffset = 0;
+        if (!suballocations1st.empty())
+        {
+            const VmaSuballocation& lastSuballoc = suballocations1st.back();
+            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size + debugMargin;
+        }
+
+        // Start from offset equal to beginning of free space.
+        VkDeviceSize resultOffset = resultBaseOffset;
+
+        // Apply alignment.
+        resultOffset = VmaAlignUp(resultOffset, allocAlignment);
+
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // Make bigger alignment if necessary.
+        if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment && !suballocations1st.empty())
+        {
+            bool bufferImageGranularityConflict = false;
+            for (size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
+            {
+                const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
+                if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
+                {
+                    if (VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
+                    {
+                        bufferImageGranularityConflict = true;
+                        break;
+                    }
+                }
+                else
+                    // Already on previous page.
+                    break;
+            }
+            if (bufferImageGranularityConflict)
+            {
+                resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
+            }
+        }
+
+        const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
+            suballocations2nd.back().offset : blockSize;
+
+        // There is enough free space at the end after alignment.
+        if (resultOffset + allocSize + debugMargin <= freeSpaceEnd)
+        {
+            // Check next suballocations for BufferImageGranularity conflicts.
+            // If conflict exists, allocation cannot be made here.
+            if ((allocSize % bufferImageGranularity || resultOffset % bufferImageGranularity) && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
+            {
+                for (size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
+                {
+                    const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
+                    if (VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+                    {
+                        if (VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
+                        {
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        // Already on previous page.
+                        break;
+                    }
+                }
+            }
+
+            // All tests passed: Success.
+            pAllocationRequest->allocHandle = (VmaAllocHandle)(resultOffset + 1);
+            // pAllocationRequest->item, customData unused.
+            pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;
+            return true;
+        }
+    }
+
+    // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
+    // beginning of 1st vector as the end of free space.
+    if (m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        VMA_ASSERT(!suballocations1st.empty());
+
+        VkDeviceSize resultBaseOffset = 0;
+        if (!suballocations2nd.empty())
+        {
+            const VmaSuballocation& lastSuballoc = suballocations2nd.back();
+            resultBaseOffset = lastSuballoc.offset + lastSuballoc.size + debugMargin;
+        }
+
+        // Start from offset equal to beginning of free space.
+        VkDeviceSize resultOffset = resultBaseOffset;
+
+        // Apply alignment.
+        resultOffset = VmaAlignUp(resultOffset, allocAlignment);
+
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // Make bigger alignment if necessary.
+        if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment && !suballocations2nd.empty())
+        {
+            bool bufferImageGranularityConflict = false;
+            for (size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
+            {
+                const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
+                if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
+                {
+                    if (VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
+                    {
+                        bufferImageGranularityConflict = true;
+                        break;
+                    }
+                }
+                else
+                    // Already on previous page.
+                    break;
+            }
+            if (bufferImageGranularityConflict)
+            {
+                resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
+            }
+        }
+
+        size_t index1st = m_1stNullItemsBeginCount;
+
+        // There is enough free space at the end after alignment.
+        if ((index1st == suballocations1st.size() && resultOffset + allocSize + debugMargin <= blockSize) ||
+            (index1st < suballocations1st.size() && resultOffset + allocSize + debugMargin <= suballocations1st[index1st].offset))
+        {
+            // Check next suballocations for BufferImageGranularity conflicts.
+            // If conflict exists, allocation cannot be made here.
+            if (allocSize % bufferImageGranularity || resultOffset % bufferImageGranularity)
+            {
+                for (size_t nextSuballocIndex = index1st;
+                    nextSuballocIndex < suballocations1st.size();
+                    nextSuballocIndex++)
+                {
+                    const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
+                    if (VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+                    {
+                        if (VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
+                        {
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        // Already on next page.
+                        break;
+                    }
+                }
+            }
+
+            // All tests passed: Success.
+            pAllocationRequest->allocHandle = (VmaAllocHandle)(resultOffset + 1);
+            pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;
+            // pAllocationRequest->item, customData unused.
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    VmaSuballocationType allocType,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    const VkDeviceSize blockSize = GetSize();
+    const VkDeviceSize bufferImageGranularity = GetBufferImageGranularity();
+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();
+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
+
+    if (m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
+    {
+        VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
+        return false;
+    }
+
+    // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
+    if (allocSize > blockSize)
+    {
+        return false;
+    }
+    VkDeviceSize resultBaseOffset = blockSize - allocSize;
+    if (!suballocations2nd.empty())
+    {
+        const VmaSuballocation& lastSuballoc = suballocations2nd.back();
+        resultBaseOffset = lastSuballoc.offset - allocSize;
+        if (allocSize > lastSuballoc.offset)
+        {
+            return false;
+        }
+    }
+
+    // Start from offset equal to end of free space.
+    VkDeviceSize resultOffset = resultBaseOffset;
+
+    const VkDeviceSize debugMargin = GetDebugMargin();
+
+    // Apply debugMargin at the end.
+    if (debugMargin > 0)
+    {
+        if (resultOffset < debugMargin)
+        {
+            return false;
+        }
+        resultOffset -= debugMargin;
+    }
+
+    // Apply alignment.
+    resultOffset = VmaAlignDown(resultOffset, allocAlignment);
+
+    // Check next suballocations from 2nd for BufferImageGranularity conflicts.
+    // Make bigger alignment if necessary.
+    if (bufferImageGranularity > 1 && bufferImageGranularity != allocAlignment && !suballocations2nd.empty())
+    {
+        bool bufferImageGranularityConflict = false;
+        for (size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
+        {
+            const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
+            if (VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
+            {
+                if (VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
+                {
+                    bufferImageGranularityConflict = true;
+                    break;
+                }
+            }
+            else
+                // Already on previous page.
+                break;
+        }
+        if (bufferImageGranularityConflict)
+        {
+            resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
+        }
+    }
+
+    // There is enough free space.
+    const VkDeviceSize endOf1st = !suballocations1st.empty() ?
+        suballocations1st.back().offset + suballocations1st.back().size :
+        0;
+    if (endOf1st + debugMargin <= resultOffset)
+    {
+        // Check previous suballocations for BufferImageGranularity conflicts.
+        // If conflict exists, allocation cannot be made here.
+        if (bufferImageGranularity > 1)
+        {
+            for (size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
+            {
+                const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
+                if (VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
+                {
+                    if (VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    // Already on next page.
+                    break;
+                }
+            }
+        }
+
+        // All tests passed: Success.
+        pAllocationRequest->allocHandle = (VmaAllocHandle)(resultOffset + 1);
+        // pAllocationRequest->item unused.
+        pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;
+        return true;
+    }
+
+    return false;
+}
+#endif // _VMA_BLOCK_METADATA_LINEAR_FUNCTIONS
+#endif // _VMA_BLOCK_METADATA_LINEAR
+
+#if 0
+#ifndef _VMA_BLOCK_METADATA_BUDDY
+/*
+- GetSize() is the original size of allocated memory block.
+- m_UsableSize is this size aligned down to a power of two.
+  All allocations and calculations happen relative to m_UsableSize.
+- GetUnusableSize() is the difference between them.
+  It is reported as separate, unused range, not available for allocations.
+
+Node at level 0 has size = m_UsableSize.
+Each next level contains nodes with size 2 times smaller than current level.
+m_LevelCount is the maximum number of levels to use in the current object.
+*/
+class VmaBlockMetadata_Buddy : public VmaBlockMetadata
+{
+    VMA_CLASS_NO_COPY(VmaBlockMetadata_Buddy)
+public:
+    VmaBlockMetadata_Buddy(const VkAllocationCallbacks* pAllocationCallbacks,
+        VkDeviceSize bufferImageGranularity, bool isVirtual);
+    virtual ~VmaBlockMetadata_Buddy();
+
+    size_t GetAllocationCount() const override { return m_AllocationCount; }
+    VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize + GetUnusableSize(); }
+    bool IsEmpty() const override { return m_Root->type == Node::TYPE_FREE; }
+    VkResult CheckCorruption(const void* pBlockData) override { return VK_ERROR_FEATURE_NOT_PRESENT; }
+    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return (VkDeviceSize)allocHandle - 1; };
+    void DebugLogAllAllocations() const override { DebugLogAllAllocationNode(m_Root, 0); }
+
+    void Init(VkDeviceSize size) override;
+    bool Validate() const override;
+
+    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
+    void AddStatistics(VmaStatistics& inoutStats) const override;
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const override;
+#endif
+
+    bool CreateAllocationRequest(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest) override;
+
+    void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        void* userData) override;
+
+    void Free(VmaAllocHandle allocHandle) override;
+    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
+    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
+    VmaAllocHandle GetAllocationListBegin() const override;
+    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
+    void Clear() override;
+    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
+
+private:
+    static const size_t MAX_LEVELS = 48;
+
+    struct ValidationContext
+    {
+        size_t calculatedAllocationCount = 0;
+        size_t calculatedFreeCount = 0;
+        VkDeviceSize calculatedSumFreeSize = 0;
+    };
+    struct Node
+    {
+        VkDeviceSize offset;
+        enum TYPE
+        {
+            TYPE_FREE,
+            TYPE_ALLOCATION,
+            TYPE_SPLIT,
+            TYPE_COUNT
+        } type;
+        Node* parent;
+        Node* buddy;
+
+        union
+        {
+            struct
+            {
+                Node* prev;
+                Node* next;
+            } free;
+            struct
+            {
+                void* userData;
+            } allocation;
+            struct
+            {
+                Node* leftChild;
+            } split;
+        };
+    };
+
+    // Size of the memory block aligned down to a power of two.
+    VkDeviceSize m_UsableSize;
+    uint32_t m_LevelCount;
+    VmaPoolAllocator<Node> m_NodeAllocator;
+    Node* m_Root;
+    struct
+    {
+        Node* front;
+        Node* back;
+    } m_FreeList[MAX_LEVELS];
+
+    // Number of nodes in the tree with type == TYPE_ALLOCATION.
+    size_t m_AllocationCount;
+    // Number of nodes in the tree with type == TYPE_FREE.
+    size_t m_FreeCount;
+    // Doesn't include space wasted due to internal fragmentation - allocation sizes are just aligned up to node sizes.
+    // Doesn't include unusable size.
+    VkDeviceSize m_SumFreeSize;
+
+    VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
+    VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }
+
+    VkDeviceSize AlignAllocationSize(VkDeviceSize size) const
+    {
+        if (!IsVirtual())
+        {
+            size = VmaAlignUp(size, (VkDeviceSize)16);
+        }
+        return VmaNextPow2(size);
+    }
+    Node* FindAllocationNode(VkDeviceSize offset, uint32_t& outLevel) const;
+    void DeleteNodeChildren(Node* node);
+    bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
+    uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
+    void AddNodeToDetailedStatistics(VmaDetailedStatistics& inoutStats, const Node* node, VkDeviceSize levelNodeSize) const;
+    // Adds node to the front of FreeList at given level.
+    // node->type must be FREE.
+    // node->free.prev, next can be undefined.
+    void AddToFreeListFront(uint32_t level, Node* node);
+    // Removes node from FreeList at given level.
+    // node->type must be FREE.
+    // node->free.prev, next stay untouched.
+    void RemoveFromFreeList(uint32_t level, Node* node);
+    void DebugLogAllAllocationNode(Node* node, uint32_t level) const;
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
+#endif
+};
+
+#ifndef _VMA_BLOCK_METADATA_BUDDY_FUNCTIONS
+VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(const VkAllocationCallbacks* pAllocationCallbacks,
+    VkDeviceSize bufferImageGranularity, bool isVirtual)
+    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
+    m_NodeAllocator(pAllocationCallbacks, 32), // firstBlockCapacity
+    m_Root(VMA_NULL),
+    m_AllocationCount(0),
+    m_FreeCount(1),
+    m_SumFreeSize(0)
+{
+    memset(m_FreeList, 0, sizeof(m_FreeList));
+}
+
+VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
+{
+    DeleteNodeChildren(m_Root);
+    m_NodeAllocator.Free(m_Root);
+}
+
+void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
+{
+    VmaBlockMetadata::Init(size);
+
+    m_UsableSize = VmaPrevPow2(size);
+    m_SumFreeSize = m_UsableSize;
+
+    // Calculate m_LevelCount.
+    const VkDeviceSize minNodeSize = IsVirtual() ? 1 : 16;
+    m_LevelCount = 1;
+    while (m_LevelCount < MAX_LEVELS &&
+        LevelToNodeSize(m_LevelCount) >= minNodeSize)
+    {
+        ++m_LevelCount;
+    }
+
+    Node* rootNode = m_NodeAllocator.Alloc();
+    rootNode->offset = 0;
+    rootNode->type = Node::TYPE_FREE;
+    rootNode->parent = VMA_NULL;
+    rootNode->buddy = VMA_NULL;
+
+    m_Root = rootNode;
+    AddToFreeListFront(0, rootNode);
+}
+
+bool VmaBlockMetadata_Buddy::Validate() const
+{
+    // Validate tree.
+    ValidationContext ctx;
+    if (!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
+    {
+        VMA_VALIDATE(false && "ValidateNode failed.");
+    }
+    VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
+    VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);
+
+    // Validate free node lists.
+    for (uint32_t level = 0; level < m_LevelCount; ++level)
+    {
+        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
+            m_FreeList[level].front->free.prev == VMA_NULL);
+
+        for (Node* node = m_FreeList[level].front;
+            node != VMA_NULL;
+            node = node->free.next)
+        {
+            VMA_VALIDATE(node->type == Node::TYPE_FREE);
+
+            if (node->free.next == VMA_NULL)
+            {
+                VMA_VALIDATE(m_FreeList[level].back == node);
+            }
+            else
+            {
+                VMA_VALIDATE(node->free.next->free.prev == node);
+            }
+        }
+    }
+
+    // Validate that free lists ar higher levels are empty.
+    for (uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
+    {
+        VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
+    }
+
+    return true;
+}
+
+void VmaBlockMetadata_Buddy::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
+{
+    inoutStats.statistics.blockCount++;
+    inoutStats.statistics.blockBytes += GetSize();
+
+    AddNodeToDetailedStatistics(inoutStats, m_Root, LevelToNodeSize(0));
+
+    const VkDeviceSize unusableSize = GetUnusableSize();
+    if (unusableSize > 0)
+        VmaAddDetailedStatisticsUnusedRange(inoutStats, unusableSize);
+}
+
+void VmaBlockMetadata_Buddy::AddStatistics(VmaStatistics& inoutStats) const
+{
+    inoutStats.blockCount++;
+    inoutStats.allocationCount += (uint32_t)m_AllocationCount;
+    inoutStats.blockBytes += GetSize();
+    inoutStats.allocationBytes += GetSize() - m_SumFreeSize;
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json, uint32_t mapRefCount) const
+{
+    VmaDetailedStatistics stats;
+    VmaClearDetailedStatistics(stats);
+    AddDetailedStatistics(stats);
+
+    PrintDetailedMap_Begin(
+        json,
+        stats.statistics.blockBytes - stats.statistics.allocationBytes,
+        stats.statistics.allocationCount,
+        stats.unusedRangeCount,
+        mapRefCount);
+
+    PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));
+
+    const VkDeviceSize unusableSize = GetUnusableSize();
+    if (unusableSize > 0)
+    {
+        PrintDetailedMap_UnusedRange(json,
+            m_UsableSize, // offset
+            unusableSize); // size
+    }
+
+    PrintDetailedMap_End(json);
+}
+#endif // VMA_STATS_STRING_ENABLED
+
+bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    bool upperAddress,
+    VmaSuballocationType allocType,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
+
+    allocSize = AlignAllocationSize(allocSize);
+
+    // Simple way to respect bufferImageGranularity. May be optimized some day.
+    // Whenever it might be an OPTIMAL image...
+    if (allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
+        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
+        allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
+    {
+        allocAlignment = VMA_MAX(allocAlignment, GetBufferImageGranularity());
+        allocSize = VmaAlignUp(allocSize, GetBufferImageGranularity());
+    }
+
+    if (allocSize > m_UsableSize)
+    {
+        return false;
+    }
+
+    const uint32_t targetLevel = AllocSizeToLevel(allocSize);
+    for (uint32_t level = targetLevel; level--; )
+    {
+        for (Node* freeNode = m_FreeList[level].front;
+            freeNode != VMA_NULL;
+            freeNode = freeNode->free.next)
+        {
+            if (freeNode->offset % allocAlignment == 0)
+            {
+                pAllocationRequest->type = VmaAllocationRequestType::Normal;
+                pAllocationRequest->allocHandle = (VmaAllocHandle)(freeNode->offset + 1);
+                pAllocationRequest->size = allocSize;
+                pAllocationRequest->customData = (void*)(uintptr_t)level;
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+void VmaBlockMetadata_Buddy::Alloc(
+    const VmaAllocationRequest& request,
+    VmaSuballocationType type,
+    void* userData)
+{
+    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
+
+    const uint32_t targetLevel = AllocSizeToLevel(request.size);
+    uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;
+
+    Node* currNode = m_FreeList[currLevel].front;
+    VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
+    const VkDeviceSize offset = (VkDeviceSize)request.allocHandle - 1;
+    while (currNode->offset != offset)
+    {
+        currNode = currNode->free.next;
+        VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
+    }
+
+    // Go down, splitting free nodes.
+    while (currLevel < targetLevel)
+    {
+        // currNode is already first free node at currLevel.
+        // Remove it from list of free nodes at this currLevel.
+        RemoveFromFreeList(currLevel, currNode);
+
+        const uint32_t childrenLevel = currLevel + 1;
+
+        // Create two free sub-nodes.
+        Node* leftChild = m_NodeAllocator.Alloc();
+        Node* rightChild = m_NodeAllocator.Alloc();
+
+        leftChild->offset = currNode->offset;
+        leftChild->type = Node::TYPE_FREE;
+        leftChild->parent = currNode;
+        leftChild->buddy = rightChild;
+
+        rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
+        rightChild->type = Node::TYPE_FREE;
+        rightChild->parent = currNode;
+        rightChild->buddy = leftChild;
+
+        // Convert current currNode to split type.
+        currNode->type = Node::TYPE_SPLIT;
+        currNode->split.leftChild = leftChild;
+
+        // Add child nodes to free list. Order is important!
+        AddToFreeListFront(childrenLevel, rightChild);
+        AddToFreeListFront(childrenLevel, leftChild);
+
+        ++m_FreeCount;
+        ++currLevel;
+        currNode = m_FreeList[currLevel].front;
+
+        /*
+        We can be sure that currNode, as left child of node previously split,
+        also fulfills the alignment requirement.
+        */
+    }
+
+    // Remove from free list.
+    VMA_ASSERT(currLevel == targetLevel &&
+        currNode != VMA_NULL &&
+        currNode->type == Node::TYPE_FREE);
+    RemoveFromFreeList(currLevel, currNode);
+
+    // Convert to allocation node.
+    currNode->type = Node::TYPE_ALLOCATION;
+    currNode->allocation.userData = userData;
+
+    ++m_AllocationCount;
+    --m_FreeCount;
+    m_SumFreeSize -= request.size;
+}
+
+void VmaBlockMetadata_Buddy::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
+{
+    uint32_t level = 0;
+    outInfo.offset = (VkDeviceSize)allocHandle - 1;
+    const Node* const node = FindAllocationNode(outInfo.offset, level);
+    outInfo.size = LevelToNodeSize(level);
+    outInfo.pUserData = node->allocation.userData;
+}
+
+void* VmaBlockMetadata_Buddy::GetAllocationUserData(VmaAllocHandle allocHandle) const
+{
+    uint32_t level = 0;
+    const Node* const node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
+    return node->allocation.userData;
+}
+
+VmaAllocHandle VmaBlockMetadata_Buddy::GetAllocationListBegin() const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    return VK_NULL_HANDLE;
+}
+
+VmaAllocHandle VmaBlockMetadata_Buddy::GetNextAllocation(VmaAllocHandle prevAlloc) const
+{
+    // Function only used for defragmentation, which is disabled for this algorithm
+    return VK_NULL_HANDLE;
+}
+
+void VmaBlockMetadata_Buddy::DeleteNodeChildren(Node* node)
+{
+    if (node->type == Node::TYPE_SPLIT)
+    {
+        DeleteNodeChildren(node->split.leftChild->buddy);
+        DeleteNodeChildren(node->split.leftChild);
+        const VkAllocationCallbacks* allocationCallbacks = GetAllocationCallbacks();
+        m_NodeAllocator.Free(node->split.leftChild->buddy);
+        m_NodeAllocator.Free(node->split.leftChild);
+    }
+}
+
+void VmaBlockMetadata_Buddy::Clear()
+{
+    DeleteNodeChildren(m_Root);
+    m_Root->type = Node::TYPE_FREE;
+    m_AllocationCount = 0;
+    m_FreeCount = 1;
+    m_SumFreeSize = m_UsableSize;
+}
+
+void VmaBlockMetadata_Buddy::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
+{
+    uint32_t level = 0;
+    Node* const node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
+    node->allocation.userData = userData;
+}
+
+VmaBlockMetadata_Buddy::Node* VmaBlockMetadata_Buddy::FindAllocationNode(VkDeviceSize offset, uint32_t& outLevel) const
+{
+    Node* node = m_Root;
+    VkDeviceSize nodeOffset = 0;
+    outLevel = 0;
+    VkDeviceSize levelNodeSize = LevelToNodeSize(0);
+    while (node->type == Node::TYPE_SPLIT)
+    {
+        const VkDeviceSize nextLevelNodeSize = levelNodeSize >> 1;
+        if (offset < nodeOffset + nextLevelNodeSize)
+        {
+            node = node->split.leftChild;
+        }
+        else
+        {
+            node = node->split.leftChild->buddy;
+            nodeOffset += nextLevelNodeSize;
+        }
+        ++outLevel;
+        levelNodeSize = nextLevelNodeSize;
+    }
+
+    VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
+    return node;
+}
+
+bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
+{
+    VMA_VALIDATE(level < m_LevelCount);
+    VMA_VALIDATE(curr->parent == parent);
+    VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
+    VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
+    switch (curr->type)
+    {
+    case Node::TYPE_FREE:
+        // curr->free.prev, next are validated separately.
+        ctx.calculatedSumFreeSize += levelNodeSize;
+        ++ctx.calculatedFreeCount;
+        break;
+    case Node::TYPE_ALLOCATION:
+        ++ctx.calculatedAllocationCount;
+        if (!IsVirtual())
+        {
+            VMA_VALIDATE(curr->allocation.userData != VMA_NULL);
+        }
+        break;
+    case Node::TYPE_SPLIT:
+    {
+        const uint32_t childrenLevel = level + 1;
+        const VkDeviceSize childrenLevelNodeSize = levelNodeSize >> 1;
+        const Node* const leftChild = curr->split.leftChild;
+        VMA_VALIDATE(leftChild != VMA_NULL);
+        VMA_VALIDATE(leftChild->offset == curr->offset);
+        if (!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
+        {
+            VMA_VALIDATE(false && "ValidateNode for left child failed.");
+        }
+        const Node* const rightChild = leftChild->buddy;
+        VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
+        if (!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
+        {
+            VMA_VALIDATE(false && "ValidateNode for right child failed.");
+        }
+    }
+    break;
+    default:
+        return false;
+    }
+
+    return true;
+}
+
+uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
+{
+    // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
+    uint32_t level = 0;
+    VkDeviceSize currLevelNodeSize = m_UsableSize;
+    VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
+    while (allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
+    {
+        ++level;
+        currLevelNodeSize >>= 1;
+        nextLevelNodeSize >>= 1;
+    }
+    return level;
+}
+
+void VmaBlockMetadata_Buddy::Free(VmaAllocHandle allocHandle)
+{
+    uint32_t level = 0;
+    Node* node = FindAllocationNode((VkDeviceSize)allocHandle - 1, level);
+
+    ++m_FreeCount;
+    --m_AllocationCount;
+    m_SumFreeSize += LevelToNodeSize(level);
+
+    node->type = Node::TYPE_FREE;
+
+    // Join free nodes if possible.
+    while (level > 0 && node->buddy->type == Node::TYPE_FREE)
+    {
+        RemoveFromFreeList(level, node->buddy);
+        Node* const parent = node->parent;
+
+        m_NodeAllocator.Free(node->buddy);
+        m_NodeAllocator.Free(node);
+        parent->type = Node::TYPE_FREE;
+
+        node = parent;
+        --level;
+        --m_FreeCount;
+    }
+
+    AddToFreeListFront(level, node);
+}
+
+void VmaBlockMetadata_Buddy::AddNodeToDetailedStatistics(VmaDetailedStatistics& inoutStats, const Node* node, VkDeviceSize levelNodeSize) const
+{
+    switch (node->type)
+    {
+    case Node::TYPE_FREE:
+        VmaAddDetailedStatisticsUnusedRange(inoutStats, levelNodeSize);
+        break;
+    case Node::TYPE_ALLOCATION:
+        VmaAddDetailedStatisticsAllocation(inoutStats, levelNodeSize);
+        break;
+    case Node::TYPE_SPLIT:
+    {
+        const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
+        const Node* const leftChild = node->split.leftChild;
+        AddNodeToDetailedStatistics(inoutStats, leftChild, childrenNodeSize);
+        const Node* const rightChild = leftChild->buddy;
+        AddNodeToDetailedStatistics(inoutStats, rightChild, childrenNodeSize);
+    }
+    break;
+    default:
+        VMA_ASSERT(0);
+    }
+}
+
+void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
+{
+    VMA_ASSERT(node->type == Node::TYPE_FREE);
+
+    // List is empty.
+    Node* const frontNode = m_FreeList[level].front;
+    if (frontNode == VMA_NULL)
+    {
+        VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
+        node->free.prev = node->free.next = VMA_NULL;
+        m_FreeList[level].front = m_FreeList[level].back = node;
+    }
+    else
+    {
+        VMA_ASSERT(frontNode->free.prev == VMA_NULL);
+        node->free.prev = VMA_NULL;
+        node->free.next = frontNode;
+        frontNode->free.prev = node;
+        m_FreeList[level].front = node;
+    }
+}
+
+void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
+{
+    VMA_ASSERT(m_FreeList[level].front != VMA_NULL);
+
+    // It is at the front.
+    if (node->free.prev == VMA_NULL)
+    {
+        VMA_ASSERT(m_FreeList[level].front == node);
+        m_FreeList[level].front = node->free.next;
+    }
+    else
+    {
+        Node* const prevFreeNode = node->free.prev;
+        VMA_ASSERT(prevFreeNode->free.next == node);
+        prevFreeNode->free.next = node->free.next;
+    }
+
+    // It is at the back.
+    if (node->free.next == VMA_NULL)
+    {
+        VMA_ASSERT(m_FreeList[level].back == node);
+        m_FreeList[level].back = node->free.prev;
+    }
+    else
+    {
+        Node* const nextFreeNode = node->free.next;
+        VMA_ASSERT(nextFreeNode->free.prev == node);
+        nextFreeNode->free.prev = node->free.prev;
+    }
+}
+
+void VmaBlockMetadata_Buddy::DebugLogAllAllocationNode(Node* node, uint32_t level) const
+{
+    switch (node->type)
+    {
+    case Node::TYPE_FREE:
+        break;
+    case Node::TYPE_ALLOCATION:
+        DebugLogAllocation(node->offset, LevelToNodeSize(level), node->allocation.userData);
+        break;
+    case Node::TYPE_SPLIT:
+    {
+        ++level;
+        DebugLogAllAllocationNode(node->split.leftChild, level);
+        DebugLogAllAllocationNode(node->split.leftChild->buddy, level);
+    }
+    break;
+    default:
+        VMA_ASSERT(0);
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
+{
+    switch (node->type)
+    {
+    case Node::TYPE_FREE:
+        PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
+        break;
+    case Node::TYPE_ALLOCATION:
+        PrintDetailedMap_Allocation(json, node->offset, levelNodeSize, node->allocation.userData);
+        break;
+    case Node::TYPE_SPLIT:
+    {
+        const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
+        const Node* const leftChild = node->split.leftChild;
+        PrintDetailedMapNode(json, leftChild, childrenNodeSize);
+        const Node* const rightChild = leftChild->buddy;
+        PrintDetailedMapNode(json, rightChild, childrenNodeSize);
+    }
+    break;
+    default:
+        VMA_ASSERT(0);
+    }
+}
+#endif // VMA_STATS_STRING_ENABLED
+#endif // _VMA_BLOCK_METADATA_BUDDY_FUNCTIONS
+#endif // _VMA_BLOCK_METADATA_BUDDY
+#endif // #if 0
+
+#ifndef _VMA_BLOCK_METADATA_TLSF
+// To not search current larger region if first allocation won't succeed and skip to smaller range
+// use with VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT as strategy in CreateAllocationRequest().
+// When fragmentation and reusal of previous blocks doesn't matter then use with
+// VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT for fastest alloc time possible.
+class VmaBlockMetadata_TLSF : public VmaBlockMetadata
+{
+    VMA_CLASS_NO_COPY(VmaBlockMetadata_TLSF)
+public:
+    VmaBlockMetadata_TLSF(const VkAllocationCallbacks* pAllocationCallbacks,
+        VkDeviceSize bufferImageGranularity, bool isVirtual);
+    virtual ~VmaBlockMetadata_TLSF();
+
+    size_t GetAllocationCount() const override { return m_AllocCount; }
+    size_t GetFreeRegionsCount() const override { return m_BlocksFreeCount + 1; }
+    VkDeviceSize GetSumFreeSize() const override { return m_BlocksFreeSize + m_NullBlock->size; }
+    bool IsEmpty() const override { return m_NullBlock->offset == 0; }
+    VkDeviceSize GetAllocationOffset(VmaAllocHandle allocHandle) const override { return ((Block*)allocHandle)->offset; };
+
+    void Init(VkDeviceSize size) override;
+    bool Validate() const override;
+
+    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const override;
+    void AddStatistics(VmaStatistics& inoutStats) const override;
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json) const override;
+#endif
+
+    bool CreateAllocationRequest(
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        bool upperAddress,
+        VmaSuballocationType allocType,
+        uint32_t strategy,
+        VmaAllocationRequest* pAllocationRequest) override;
+
+    VkResult CheckCorruption(const void* pBlockData) override;
+    void Alloc(
+        const VmaAllocationRequest& request,
+        VmaSuballocationType type,
+        void* userData) override;
+
+    void Free(VmaAllocHandle allocHandle) override;
+    void GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo) override;
+    void* GetAllocationUserData(VmaAllocHandle allocHandle) const override;
+    VmaAllocHandle GetAllocationListBegin() const override;
+    VmaAllocHandle GetNextAllocation(VmaAllocHandle prevAlloc) const override;
+    VkDeviceSize GetNextFreeRegionSize(VmaAllocHandle alloc) const override;
+    void Clear() override;
+    void SetAllocationUserData(VmaAllocHandle allocHandle, void* userData) override;
+    void DebugLogAllAllocations() const override;
+
+private:
+    // According to original paper it should be preferable 4 or 5:
+    // M. Masmano, I. Ripoll, A. Crespo, and J. Real "TLSF: a New Dynamic Memory Allocator for Real-Time Systems"
+    // http://www.gii.upv.es/tlsf/files/ecrts04_tlsf.pdf
+    static const uint8_t SECOND_LEVEL_INDEX = 5;
+    static const uint16_t SMALL_BUFFER_SIZE = 256;
+    static const uint32_t INITIAL_BLOCK_ALLOC_COUNT = 16;
+    static const uint8_t MEMORY_CLASS_SHIFT = 7;
+    static const uint8_t MAX_MEMORY_CLASSES = 65 - MEMORY_CLASS_SHIFT;
+
+    class Block
+    {
+    public:
+        VkDeviceSize offset;
+        VkDeviceSize size;
+        Block* prevPhysical;
+        Block* nextPhysical;
+
+        void MarkFree() { prevFree = VMA_NULL; }
+        void MarkTaken() { prevFree = this; }
+        bool IsFree() const { return prevFree != this; }
+        void*& UserData() { VMA_HEAVY_ASSERT(!IsFree()); return userData; }
+        Block*& PrevFree() { return prevFree; }
+        Block*& NextFree() { VMA_HEAVY_ASSERT(IsFree()); return nextFree; }
+
+    private:
+        Block* prevFree; // Address of the same block here indicates that block is taken
+        union
+        {
+            Block* nextFree;
+            void* userData;
+        };
+    };
+
+    size_t m_AllocCount;
+    // Total number of free blocks besides null block
+    size_t m_BlocksFreeCount;
+    // Total size of free blocks excluding null block
+    VkDeviceSize m_BlocksFreeSize;
+    uint32_t m_IsFreeBitmap;
+    uint8_t m_MemoryClasses;
+    uint32_t m_InnerIsFreeBitmap[MAX_MEMORY_CLASSES];
+    uint32_t m_ListsCount;
+    /*
+    * 0: 0-3 lists for small buffers
+    * 1+: 0-(2^SLI-1) lists for normal buffers
+    */
+    Block** m_FreeList;
+    VmaPoolAllocator<Block> m_BlockAllocator;
+    Block* m_NullBlock;
+    VmaBlockBufferImageGranularity m_GranularityHandler;
+
+    uint8_t SizeToMemoryClass(VkDeviceSize size) const;
+    uint16_t SizeToSecondIndex(VkDeviceSize size, uint8_t memoryClass) const;
+    uint32_t GetListIndex(uint8_t memoryClass, uint16_t secondIndex) const;
+    uint32_t GetListIndex(VkDeviceSize size) const;
+
+    void RemoveFreeBlock(Block* block);
+    void InsertFreeBlock(Block* block);
+    void MergeBlock(Block* block, Block* prev);
+
+    Block* FindFreeBlock(VkDeviceSize size, uint32_t& listIndex) const;
+    bool CheckBlock(
+        Block& block,
+        uint32_t listIndex,
+        VkDeviceSize allocSize,
+        VkDeviceSize allocAlignment,
+        VmaSuballocationType allocType,
+        VmaAllocationRequest* pAllocationRequest);
+};
+
+#ifndef _VMA_BLOCK_METADATA_TLSF_FUNCTIONS
+VmaBlockMetadata_TLSF::VmaBlockMetadata_TLSF(const VkAllocationCallbacks* pAllocationCallbacks,
+    VkDeviceSize bufferImageGranularity, bool isVirtual)
+    : VmaBlockMetadata(pAllocationCallbacks, bufferImageGranularity, isVirtual),
+    m_AllocCount(0),
+    m_BlocksFreeCount(0),
+    m_BlocksFreeSize(0),
+    m_IsFreeBitmap(0),
+    m_MemoryClasses(0),
+    m_ListsCount(0),
+    m_FreeList(VMA_NULL),
+    m_BlockAllocator(pAllocationCallbacks, INITIAL_BLOCK_ALLOC_COUNT),
+    m_NullBlock(VMA_NULL),
+    m_GranularityHandler(bufferImageGranularity) {}
+
+VmaBlockMetadata_TLSF::~VmaBlockMetadata_TLSF()
+{
+    if (m_FreeList)
+        vma_delete_array(GetAllocationCallbacks(), m_FreeList, m_ListsCount);
+    m_GranularityHandler.Destroy(GetAllocationCallbacks());
+}
+
+void VmaBlockMetadata_TLSF::Init(VkDeviceSize size)
+{
+    VmaBlockMetadata::Init(size);
+
+    if (!IsVirtual())
+        m_GranularityHandler.Init(GetAllocationCallbacks(), size);
+
+    m_NullBlock = m_BlockAllocator.Alloc();
+    m_NullBlock->size = size;
+    m_NullBlock->offset = 0;
+    m_NullBlock->prevPhysical = VMA_NULL;
+    m_NullBlock->nextPhysical = VMA_NULL;
+    m_NullBlock->MarkFree();
+    m_NullBlock->NextFree() = VMA_NULL;
+    m_NullBlock->PrevFree() = VMA_NULL;
+    uint8_t memoryClass = SizeToMemoryClass(size);
+    uint16_t sli = SizeToSecondIndex(size, memoryClass);
+    m_ListsCount = (memoryClass == 0 ? 0 : (memoryClass - 1) * (1UL << SECOND_LEVEL_INDEX) + sli) + 1;
+    if (IsVirtual())
+        m_ListsCount += 1UL << SECOND_LEVEL_INDEX;
+    else
+        m_ListsCount += 4;
+
+    m_MemoryClasses = memoryClass + 2;
+    memset(m_InnerIsFreeBitmap, 0, MAX_MEMORY_CLASSES * sizeof(uint32_t));
+
+    m_FreeList = vma_new_array(GetAllocationCallbacks(), Block*, m_ListsCount);
+    memset(m_FreeList, 0, m_ListsCount * sizeof(Block*));
+}
+
+bool VmaBlockMetadata_TLSF::Validate() const
+{
+    VMA_VALIDATE(GetSumFreeSize() <= GetSize());
+
+    VkDeviceSize calculatedSize = m_NullBlock->size;
+    VkDeviceSize calculatedFreeSize = m_NullBlock->size;
+    size_t allocCount = 0;
+    size_t freeCount = 0;
+
+    // Check integrity of free lists
+    for (uint32_t list = 0; list < m_ListsCount; ++list)
+    {
+        Block* block = m_FreeList[list];
+        if (block != VMA_NULL)
+        {
+            VMA_VALIDATE(block->IsFree());
+            VMA_VALIDATE(block->PrevFree() == VMA_NULL);
+            while (block->NextFree())
+            {
+                VMA_VALIDATE(block->NextFree()->IsFree());
+                VMA_VALIDATE(block->NextFree()->PrevFree() == block);
+                block = block->NextFree();
+            }
+        }
+    }
+
+    VkDeviceSize nextOffset = m_NullBlock->offset;
+    auto validateCtx = m_GranularityHandler.StartValidation(GetAllocationCallbacks(), IsVirtual());
+
+    VMA_VALIDATE(m_NullBlock->nextPhysical == VMA_NULL);
+    if (m_NullBlock->prevPhysical)
+    {
+        VMA_VALIDATE(m_NullBlock->prevPhysical->nextPhysical == m_NullBlock);
+    }
+    // Check all blocks
+    for (Block* prev = m_NullBlock->prevPhysical; prev != VMA_NULL; prev = prev->prevPhysical)
+    {
+        VMA_VALIDATE(prev->offset + prev->size == nextOffset);
+        nextOffset = prev->offset;
+        calculatedSize += prev->size;
+
+        uint32_t listIndex = GetListIndex(prev->size);
+        if (prev->IsFree())
+        {
+            ++freeCount;
+            // Check if free block belongs to free list
+            Block* freeBlock = m_FreeList[listIndex];
+            VMA_VALIDATE(freeBlock != VMA_NULL);
+
+            bool found = false;
+            do
+            {
+                if (freeBlock == prev)
+                    found = true;
+
+                freeBlock = freeBlock->NextFree();
+            } while (!found && freeBlock != VMA_NULL);
+
+            VMA_VALIDATE(found);
+            calculatedFreeSize += prev->size;
+        }
+        else
+        {
+            ++allocCount;
+            // Check if taken block is not on a free list
+            Block* freeBlock = m_FreeList[listIndex];
+            while (freeBlock)
+            {
+                VMA_VALIDATE(freeBlock != prev);
+                freeBlock = freeBlock->NextFree();
+            }
+
+            if (!IsVirtual())
+            {
+                VMA_VALIDATE(m_GranularityHandler.Validate(validateCtx, prev->offset, prev->size));
+            }
+        }
+
+        if (prev->prevPhysical)
+        {
+            VMA_VALIDATE(prev->prevPhysical->nextPhysical == prev);
+        }
+    }
+
+    if (!IsVirtual())
+    {
+        VMA_VALIDATE(m_GranularityHandler.FinishValidation(validateCtx));
+    }
+
+    VMA_VALIDATE(nextOffset == 0);
+    VMA_VALIDATE(calculatedSize == GetSize());
+    VMA_VALIDATE(calculatedFreeSize == GetSumFreeSize());
+    VMA_VALIDATE(allocCount == m_AllocCount);
+    VMA_VALIDATE(freeCount == m_BlocksFreeCount);
+
+    return true;
+}
+
+void VmaBlockMetadata_TLSF::AddDetailedStatistics(VmaDetailedStatistics& inoutStats) const
+{
+    inoutStats.statistics.blockCount++;
+    inoutStats.statistics.blockBytes += GetSize();
+    if (m_NullBlock->size > 0)
+        VmaAddDetailedStatisticsUnusedRange(inoutStats, m_NullBlock->size);
+
+    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
+    {
+        if (block->IsFree())
+            VmaAddDetailedStatisticsUnusedRange(inoutStats, block->size);
+        else
+            VmaAddDetailedStatisticsAllocation(inoutStats, block->size);
+    }
+}
+
+void VmaBlockMetadata_TLSF::AddStatistics(VmaStatistics& inoutStats) const
+{
+    inoutStats.blockCount++;
+    inoutStats.allocationCount += (uint32_t)m_AllocCount;
+    inoutStats.blockBytes += GetSize();
+    inoutStats.allocationBytes += GetSize() - GetSumFreeSize();
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockMetadata_TLSF::PrintDetailedMap(class VmaJsonWriter& json) const
+{
+    size_t blockCount = m_AllocCount + m_BlocksFreeCount;
+    VmaStlAllocator<Block*> allocator(GetAllocationCallbacks());
+    VmaVector<Block*, VmaStlAllocator<Block*>> blockList(blockCount, allocator);
+
+    size_t i = blockCount;
+    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
+    {
+        blockList[--i] = block;
+    }
+    VMA_ASSERT(i == 0);
+
+    VmaDetailedStatistics stats;
+    VmaClearDetailedStatistics(stats);
+    AddDetailedStatistics(stats);
+
+    PrintDetailedMap_Begin(json,
+        stats.statistics.blockBytes - stats.statistics.allocationBytes,
+        stats.statistics.allocationCount,
+        stats.unusedRangeCount);
+
+    for (; i < blockCount; ++i)
+    {
+        Block* block = blockList[i];
+        if (block->IsFree())
+            PrintDetailedMap_UnusedRange(json, block->offset, block->size);
+        else
+            PrintDetailedMap_Allocation(json, block->offset, block->size, block->UserData());
+    }
+    if (m_NullBlock->size > 0)
+        PrintDetailedMap_UnusedRange(json, m_NullBlock->offset, m_NullBlock->size);
+
+    PrintDetailedMap_End(json);
+}
+#endif
+
+bool VmaBlockMetadata_TLSF::CreateAllocationRequest(
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    bool upperAddress,
+    VmaSuballocationType allocType,
+    uint32_t strategy,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(allocSize > 0 && "Cannot allocate empty block!");
+    VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
+
+    // For small granularity round up
+    if (!IsVirtual())
+        m_GranularityHandler.RoundupAllocRequest(allocType, allocSize, allocAlignment);
+
+    allocSize += GetDebugMargin();
+    // Quick check for too small pool
+    if (allocSize > GetSumFreeSize())
+        return false;
+
+    // If no free blocks in pool then check only null block
+    if (m_BlocksFreeCount == 0)
+        return CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest);
+
+    // Round up to the next block
+    VkDeviceSize sizeForNextList = allocSize;
+    VkDeviceSize smallSizeStep = SMALL_BUFFER_SIZE / (IsVirtual() ? 1 << SECOND_LEVEL_INDEX : 4);
+    if (allocSize > SMALL_BUFFER_SIZE)
+    {
+        sizeForNextList += (1ULL << (VMA_BITSCAN_MSB(allocSize) - SECOND_LEVEL_INDEX));
+    }
+    else if (allocSize > SMALL_BUFFER_SIZE - smallSizeStep)
+        sizeForNextList = SMALL_BUFFER_SIZE + 1;
+    else
+        sizeForNextList += smallSizeStep;
+
+    uint32_t nextListIndex = 0;
+    uint32_t prevListIndex = 0;
+    Block* nextListBlock = VMA_NULL;
+    Block* prevListBlock = VMA_NULL;
+
+    // Check blocks according to strategies
+    if (strategy & VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT)
+    {
+        // Quick check for larger block first
+        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
+        if (nextListBlock != VMA_NULL && CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+            return true;
+
+        // If not fitted then null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
+            return true;
+
+        // Null block failed, search larger bucket
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+
+        // Failed again, check best fit bucket
+        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
+        while (prevListBlock)
+        {
+            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+            prevListBlock = prevListBlock->NextFree();
+        }
+    }
+    else if (strategy & VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT)
+    {
+        // Check best fit bucket
+        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
+        while (prevListBlock)
+        {
+            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+            prevListBlock = prevListBlock->NextFree();
+        }
+
+        // If failed check null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
+            return true;
+
+        // Check larger bucket
+        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+    }
+    else if (strategy & VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT )
+    {
+        // Perform search from the start
+        VmaStlAllocator<Block*> allocator(GetAllocationCallbacks());
+        VmaVector<Block*, VmaStlAllocator<Block*>> blockList(m_BlocksFreeCount, allocator);
+
+        size_t i = m_BlocksFreeCount;
+        for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
+        {
+            if (block->IsFree() && block->size >= allocSize)
+                blockList[--i] = block;
+        }
+
+        for (; i < m_BlocksFreeCount; ++i)
+        {
+            Block& block = *blockList[i];
+            if (CheckBlock(block, GetListIndex(block.size), allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+        }
+
+        // If failed check null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
+            return true;
+
+        // Whole range searched, no more memory
+        return false;
+    }
+    else
+    {
+        // Check larger bucket
+        nextListBlock = FindFreeBlock(sizeForNextList, nextListIndex);
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+
+        // If failed check null block
+        if (CheckBlock(*m_NullBlock, m_ListsCount, allocSize, allocAlignment, allocType, pAllocationRequest))
+            return true;
+
+        // Check best fit bucket
+        prevListBlock = FindFreeBlock(allocSize, prevListIndex);
+        while (prevListBlock)
+        {
+            if (CheckBlock(*prevListBlock, prevListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+            prevListBlock = prevListBlock->NextFree();
+        }
+    }
+
+    // Worst case, full search has to be done
+    while (++nextListIndex < m_ListsCount)
+    {
+        nextListBlock = m_FreeList[nextListIndex];
+        while (nextListBlock)
+        {
+            if (CheckBlock(*nextListBlock, nextListIndex, allocSize, allocAlignment, allocType, pAllocationRequest))
+                return true;
+            nextListBlock = nextListBlock->NextFree();
+        }
+    }
+
+    // No more memory sadly
+    return false;
+}
+
+VkResult VmaBlockMetadata_TLSF::CheckCorruption(const void* pBlockData)
+{
+    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
+    {
+        if (!block->IsFree())
+        {
+            if (!VmaValidateMagicValue(pBlockData, block->offset + block->size))
+            {
+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
+                return VK_ERROR_UNKNOWN_COPY;
+            }
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaBlockMetadata_TLSF::Alloc(
+    const VmaAllocationRequest& request,
+    VmaSuballocationType type,
+    void* userData)
+{
+    VMA_ASSERT(request.type == VmaAllocationRequestType::TLSF);
+
+    // Get block and pop it from the free list
+    Block* currentBlock = (Block*)request.allocHandle;
+    VkDeviceSize offset = request.algorithmData;
+    VMA_ASSERT(currentBlock != VMA_NULL);
+    VMA_ASSERT(currentBlock->offset <= offset);
+
+    if (currentBlock != m_NullBlock)
+        RemoveFreeBlock(currentBlock);
+
+    VkDeviceSize debugMargin = GetDebugMargin();
+    VkDeviceSize misssingAlignment = offset - currentBlock->offset;
+
+    // Append missing alignment to prev block or create new one
+    if (misssingAlignment)
+    {
+        Block* prevBlock = currentBlock->prevPhysical;
+        VMA_ASSERT(prevBlock != VMA_NULL && "There should be no missing alignment at offset 0!");
+
+        if (prevBlock->IsFree() && prevBlock->size != debugMargin)
+        {
+            uint32_t oldList = GetListIndex(prevBlock->size);
+            prevBlock->size += misssingAlignment;
+            // Check if new size crosses list bucket
+            if (oldList != GetListIndex(prevBlock->size))
+            {
+                prevBlock->size -= misssingAlignment;
+                RemoveFreeBlock(prevBlock);
+                prevBlock->size += misssingAlignment;
+                InsertFreeBlock(prevBlock);
+            }
+            else
+                m_BlocksFreeSize += misssingAlignment;
+        }
+        else
+        {
+            Block* newBlock = m_BlockAllocator.Alloc();
+            currentBlock->prevPhysical = newBlock;
+            prevBlock->nextPhysical = newBlock;
+            newBlock->prevPhysical = prevBlock;
+            newBlock->nextPhysical = currentBlock;
+            newBlock->size = misssingAlignment;
+            newBlock->offset = currentBlock->offset;
+            newBlock->MarkTaken();
+
+            InsertFreeBlock(newBlock);
+        }
+
+        currentBlock->size -= misssingAlignment;
+        currentBlock->offset += misssingAlignment;
+    }
+
+    VkDeviceSize size = request.size + debugMargin;
+    if (currentBlock->size == size)
+    {
+        if (currentBlock == m_NullBlock)
+        {
+            // Setup new null block
+            m_NullBlock = m_BlockAllocator.Alloc();
+            m_NullBlock->size = 0;
+            m_NullBlock->offset = currentBlock->offset + size;
+            m_NullBlock->prevPhysical = currentBlock;
+            m_NullBlock->nextPhysical = VMA_NULL;
+            m_NullBlock->MarkFree();
+            m_NullBlock->PrevFree() = VMA_NULL;
+            m_NullBlock->NextFree() = VMA_NULL;
+            currentBlock->nextPhysical = m_NullBlock;
+            currentBlock->MarkTaken();
+        }
+    }
+    else
+    {
+        VMA_ASSERT(currentBlock->size > size && "Proper block already found, shouldn't find smaller one!");
+
+        // Create new free block
+        Block* newBlock = m_BlockAllocator.Alloc();
+        newBlock->size = currentBlock->size - size;
+        newBlock->offset = currentBlock->offset + size;
+        newBlock->prevPhysical = currentBlock;
+        newBlock->nextPhysical = currentBlock->nextPhysical;
+        currentBlock->nextPhysical = newBlock;
+        currentBlock->size = size;
+
+        if (currentBlock == m_NullBlock)
+        {
+            m_NullBlock = newBlock;
+            m_NullBlock->MarkFree();
+            m_NullBlock->NextFree() = VMA_NULL;
+            m_NullBlock->PrevFree() = VMA_NULL;
+            currentBlock->MarkTaken();
+        }
+        else
+        {
+            newBlock->nextPhysical->prevPhysical = newBlock;
+            newBlock->MarkTaken();
+            InsertFreeBlock(newBlock);
+        }
+    }
+    currentBlock->UserData() = userData;
+
+    if (debugMargin > 0)
+    {
+        currentBlock->size -= debugMargin;
+        Block* newBlock = m_BlockAllocator.Alloc();
+        newBlock->size = debugMargin;
+        newBlock->offset = currentBlock->offset + currentBlock->size;
+        newBlock->prevPhysical = currentBlock;
+        newBlock->nextPhysical = currentBlock->nextPhysical;
+        newBlock->MarkTaken();
+        currentBlock->nextPhysical->prevPhysical = newBlock;
+        currentBlock->nextPhysical = newBlock;
+        InsertFreeBlock(newBlock);
+    }
+
+    if (!IsVirtual())
+        m_GranularityHandler.AllocPages((uint8_t)(uintptr_t)request.customData,
+            currentBlock->offset, currentBlock->size);
+    ++m_AllocCount;
+}
+
+void VmaBlockMetadata_TLSF::Free(VmaAllocHandle allocHandle)
+{
+    Block* block = (Block*)allocHandle;
+    Block* next = block->nextPhysical;
+    VMA_ASSERT(!block->IsFree() && "Block is already free!");
+
+    if (!IsVirtual())
+        m_GranularityHandler.FreePages(block->offset, block->size);
+    --m_AllocCount;
+
+    VkDeviceSize debugMargin = GetDebugMargin();
+    if (debugMargin > 0)
+    {
+        RemoveFreeBlock(next);
+        MergeBlock(next, block);
+        block = next;
+        next = next->nextPhysical;
+    }
+
+    // Try merging
+    Block* prev = block->prevPhysical;
+    if (prev != VMA_NULL && prev->IsFree() && prev->size != debugMargin)
+    {
+        RemoveFreeBlock(prev);
+        MergeBlock(block, prev);
+    }
+
+    if (!next->IsFree())
+        InsertFreeBlock(block);
+    else if (next == m_NullBlock)
+        MergeBlock(m_NullBlock, block);
+    else
+    {
+        RemoveFreeBlock(next);
+        MergeBlock(next, block);
+        InsertFreeBlock(next);
+    }
+}
+
+void VmaBlockMetadata_TLSF::GetAllocationInfo(VmaAllocHandle allocHandle, VmaVirtualAllocationInfo& outInfo)
+{
+    Block* block = (Block*)allocHandle;
+    VMA_ASSERT(!block->IsFree() && "Cannot get allocation info for free block!");
+    outInfo.offset = block->offset;
+    outInfo.size = block->size;
+    outInfo.pUserData = block->UserData();
+}
+
+void* VmaBlockMetadata_TLSF::GetAllocationUserData(VmaAllocHandle allocHandle) const
+{
+    Block* block = (Block*)allocHandle;
+    VMA_ASSERT(!block->IsFree() && "Cannot get user data for free block!");
+    return block->UserData();
+}
+
+VmaAllocHandle VmaBlockMetadata_TLSF::GetAllocationListBegin() const
+{
+    if (m_AllocCount == 0)
+        return VK_NULL_HANDLE;
+
+    for (Block* block = m_NullBlock->prevPhysical; block; block = block->prevPhysical)
+    {
+        if (!block->IsFree())
+            return (VmaAllocHandle)block;
+    }
+    VMA_ASSERT(false && "If m_AllocCount > 0 then should find any allocation!");
+    return VK_NULL_HANDLE;
+}
+
+VmaAllocHandle VmaBlockMetadata_TLSF::GetNextAllocation(VmaAllocHandle prevAlloc) const
+{
+    Block* startBlock = (Block*)prevAlloc;
+    VMA_ASSERT(!startBlock->IsFree() && "Incorrect block!");
+
+    for (Block* block = startBlock->prevPhysical; block; block = block->prevPhysical)
+    {
+        if (!block->IsFree())
+            return (VmaAllocHandle)block;
+    }
+    return VK_NULL_HANDLE;
+}
+
+VkDeviceSize VmaBlockMetadata_TLSF::GetNextFreeRegionSize(VmaAllocHandle alloc) const
+{
+    Block* block = (Block*)alloc;
+    VMA_ASSERT(!block->IsFree() && "Incorrect block!");
+
+    if (block->prevPhysical)
+        return block->prevPhysical->IsFree() ? block->prevPhysical->size : 0;
+    return 0;
+}
+
+void VmaBlockMetadata_TLSF::Clear()
+{
+    m_AllocCount = 0;
+    m_BlocksFreeCount = 0;
+    m_BlocksFreeSize = 0;
+    m_IsFreeBitmap = 0;
+    m_NullBlock->offset = 0;
+    m_NullBlock->size = GetSize();
+    Block* block = m_NullBlock->prevPhysical;
+    m_NullBlock->prevPhysical = VMA_NULL;
+    while (block)
+    {
+        Block* prev = block->prevPhysical;
+        m_BlockAllocator.Free(block);
+        block = prev;
+    }
+    memset(m_FreeList, 0, m_ListsCount * sizeof(Block*));
+    memset(m_InnerIsFreeBitmap, 0, m_MemoryClasses * sizeof(uint32_t));
+    m_GranularityHandler.Clear();
+}
+
+void VmaBlockMetadata_TLSF::SetAllocationUserData(VmaAllocHandle allocHandle, void* userData)
+{
+    Block* block = (Block*)allocHandle;
+    VMA_ASSERT(!block->IsFree() && "Trying to set user data for not allocated block!");
+    block->UserData() = userData;
+}
+
+void VmaBlockMetadata_TLSF::DebugLogAllAllocations() const
+{
+    for (Block* block = m_NullBlock->prevPhysical; block != VMA_NULL; block = block->prevPhysical)
+        if (!block->IsFree())
+            DebugLogAllocation(block->offset, block->size, block->UserData());
+}
+
+uint8_t VmaBlockMetadata_TLSF::SizeToMemoryClass(VkDeviceSize size) const
+{
+    if (size > SMALL_BUFFER_SIZE)
+        return VMA_BITSCAN_MSB(size) - MEMORY_CLASS_SHIFT;
+    return 0;
+}
+
+uint16_t VmaBlockMetadata_TLSF::SizeToSecondIndex(VkDeviceSize size, uint8_t memoryClass) const
+{
+    if (memoryClass == 0)
+    {
+        if (IsVirtual())
+            return static_cast<uint16_t>((size - 1) / 8);
+        else
+            return static_cast<uint16_t>((size - 1) / 64);
+    }
+    return static_cast<uint16_t>((size >> (memoryClass + MEMORY_CLASS_SHIFT - SECOND_LEVEL_INDEX)) ^ (1U << SECOND_LEVEL_INDEX));
+}
+
+uint32_t VmaBlockMetadata_TLSF::GetListIndex(uint8_t memoryClass, uint16_t secondIndex) const
+{
+    if (memoryClass == 0)
+        return secondIndex;
+
+    const uint32_t index = static_cast<uint32_t>(memoryClass - 1) * (1 << SECOND_LEVEL_INDEX) + secondIndex;
+    if (IsVirtual())
+        return index + (1 << SECOND_LEVEL_INDEX);
+    else
+        return index + 4;
+}
+
+uint32_t VmaBlockMetadata_TLSF::GetListIndex(VkDeviceSize size) const
+{
+    uint8_t memoryClass = SizeToMemoryClass(size);
+    return GetListIndex(memoryClass, SizeToSecondIndex(size, memoryClass));
+}
+
+void VmaBlockMetadata_TLSF::RemoveFreeBlock(Block* block)
+{
+    VMA_ASSERT(block != m_NullBlock);
+    VMA_ASSERT(block->IsFree());
+
+    if (block->NextFree() != VMA_NULL)
+        block->NextFree()->PrevFree() = block->PrevFree();
+    if (block->PrevFree() != VMA_NULL)
+        block->PrevFree()->NextFree() = block->NextFree();
+    else
+    {
+        uint8_t memClass = SizeToMemoryClass(block->size);
+        uint16_t secondIndex = SizeToSecondIndex(block->size, memClass);
+        uint32_t index = GetListIndex(memClass, secondIndex);
+        VMA_ASSERT(m_FreeList[index] == block);
+        m_FreeList[index] = block->NextFree();
+        if (block->NextFree() == VMA_NULL)
+        {
+            m_InnerIsFreeBitmap[memClass] &= ~(1U << secondIndex);
+            if (m_InnerIsFreeBitmap[memClass] == 0)
+                m_IsFreeBitmap &= ~(1UL << memClass);
+        }
+    }
+    block->MarkTaken();
+    block->UserData() = VMA_NULL;
+    --m_BlocksFreeCount;
+    m_BlocksFreeSize -= block->size;
+}
+
+void VmaBlockMetadata_TLSF::InsertFreeBlock(Block* block)
+{
+    VMA_ASSERT(block != m_NullBlock);
+    VMA_ASSERT(!block->IsFree() && "Cannot insert block twice!");
+
+    uint8_t memClass = SizeToMemoryClass(block->size);
+    uint16_t secondIndex = SizeToSecondIndex(block->size, memClass);
+    uint32_t index = GetListIndex(memClass, secondIndex);
+    VMA_ASSERT(index < m_ListsCount);
+    block->PrevFree() = VMA_NULL;
+    block->NextFree() = m_FreeList[index];
+    m_FreeList[index] = block;
+    if (block->NextFree() != VMA_NULL)
+        block->NextFree()->PrevFree() = block;
+    else
+    {
+        m_InnerIsFreeBitmap[memClass] |= 1U << secondIndex;
+        m_IsFreeBitmap |= 1UL << memClass;
+    }
+    ++m_BlocksFreeCount;
+    m_BlocksFreeSize += block->size;
+}
+
+void VmaBlockMetadata_TLSF::MergeBlock(Block* block, Block* prev)
+{
+    VMA_ASSERT(block->prevPhysical == prev && "Cannot merge seperate physical regions!");
+    VMA_ASSERT(!prev->IsFree() && "Cannot merge block that belongs to free list!");
+
+    block->offset = prev->offset;
+    block->size += prev->size;
+    block->prevPhysical = prev->prevPhysical;
+    if (block->prevPhysical)
+        block->prevPhysical->nextPhysical = block;
+    m_BlockAllocator.Free(prev);
+}
+
+VmaBlockMetadata_TLSF::Block* VmaBlockMetadata_TLSF::FindFreeBlock(VkDeviceSize size, uint32_t& listIndex) const
+{
+    uint8_t memoryClass = SizeToMemoryClass(size);
+    uint32_t innerFreeMap = m_InnerIsFreeBitmap[memoryClass] & (~0U << SizeToSecondIndex(size, memoryClass));
+    if (!innerFreeMap)
+    {
+        // Check higher levels for avaiable blocks
+        uint32_t freeMap = m_IsFreeBitmap & (~0UL << (memoryClass + 1));
+        if (!freeMap)
+            return VMA_NULL; // No more memory avaible
+
+        // Find lowest free region
+        memoryClass = VMA_BITSCAN_LSB(freeMap);
+        innerFreeMap = m_InnerIsFreeBitmap[memoryClass];
+        VMA_ASSERT(innerFreeMap != 0);
+    }
+    // Find lowest free subregion
+    listIndex = GetListIndex(memoryClass, VMA_BITSCAN_LSB(innerFreeMap));
+    VMA_ASSERT(m_FreeList[listIndex]);
+    return m_FreeList[listIndex];
+}
+
+bool VmaBlockMetadata_TLSF::CheckBlock(
+    Block& block,
+    uint32_t listIndex,
+    VkDeviceSize allocSize,
+    VkDeviceSize allocAlignment,
+    VmaSuballocationType allocType,
+    VmaAllocationRequest* pAllocationRequest)
+{
+    VMA_ASSERT(block.IsFree() && "Block is already taken!");
+
+    VkDeviceSize alignedOffset = VmaAlignUp(block.offset, allocAlignment);
+    if (block.size < allocSize + alignedOffset - block.offset)
+        return false;
+
+    // Check for granularity conflicts
+    if (!IsVirtual() &&
+        m_GranularityHandler.CheckConflictAndAlignUp(alignedOffset, allocSize, block.offset, block.size, allocType))
+        return false;
+
+    // Alloc successful
+    pAllocationRequest->type = VmaAllocationRequestType::TLSF;
+    pAllocationRequest->allocHandle = (VmaAllocHandle)&block;
+    pAllocationRequest->size = allocSize - GetDebugMargin();
+    pAllocationRequest->customData = (void*)allocType;
+    pAllocationRequest->algorithmData = alignedOffset;
+
+    // Place block at the start of list if it's normal block
+    if (listIndex != m_ListsCount && block.PrevFree())
+    {
+        block.PrevFree()->NextFree() = block.NextFree();
+        if (block.NextFree())
+            block.NextFree()->PrevFree() = block.PrevFree();
+        block.PrevFree() = VMA_NULL;
+        block.NextFree() = m_FreeList[listIndex];
+        m_FreeList[listIndex] = &block;
+        if (block.NextFree())
+            block.NextFree()->PrevFree() = &block;
+    }
+
+    return true;
+}
+#endif // _VMA_BLOCK_METADATA_TLSF_FUNCTIONS
+#endif // _VMA_BLOCK_METADATA_TLSF
+
+#ifndef _VMA_BLOCK_VECTOR
+/*
+Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
+Vulkan memory type.
+
+Synchronized internally with a mutex.
+*/
+class VmaBlockVector
+{
+    friend struct VmaDefragmentationContext_T;
+    VMA_CLASS_NO_COPY(VmaBlockVector)
+public:
+    VmaBlockVector(
+        VmaAllocator hAllocator,
+        VmaPool hParentPool,
+        uint32_t memoryTypeIndex,
+        VkDeviceSize preferredBlockSize,
+        size_t minBlockCount,
+        size_t maxBlockCount,
+        VkDeviceSize bufferImageGranularity,
+        bool explicitBlockSize,
+        uint32_t algorithm,
+        float priority,
+        VkDeviceSize minAllocationAlignment,
+        void* pMemoryAllocateNext);
+    ~VmaBlockVector();
+
+    VmaAllocator GetAllocator() const { return m_hAllocator; }
+    VmaPool GetParentPool() const { return m_hParentPool; }
+    bool IsCustomPool() const { return m_hParentPool != VMA_NULL; }
+    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
+    VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
+    VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
+    uint32_t GetAlgorithm() const { return m_Algorithm; }
+    bool HasExplicitBlockSize() const { return m_ExplicitBlockSize; }
+    float GetPriority() const { return m_Priority; }
+    const void* GetAllocationNextPtr() const { return m_pMemoryAllocateNext; }
+    // To be used only while the m_Mutex is locked. Used during defragmentation.
+    size_t GetBlockCount() const { return m_Blocks.size(); }
+    // To be used only while the m_Mutex is locked. Used during defragmentation.
+    VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
+    VMA_RW_MUTEX &GetMutex() { return m_Mutex; }
+
+    VkResult CreateMinBlocks();
+    void AddStatistics(VmaStatistics& inoutStats);
+    void AddDetailedStatistics(VmaDetailedStatistics& inoutStats);
+    bool IsEmpty();
+    bool IsCorruptionDetectionEnabled() const;
+
+    VkResult Allocate(
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaSuballocationType suballocType,
+        size_t allocationCount,
+        VmaAllocation* pAllocations);
+
+    void Free(const VmaAllocation hAllocation);
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json);
+#endif
+
+    VkResult CheckCorruption();
+
+private:
+    const VmaAllocator m_hAllocator;
+    const VmaPool m_hParentPool;
+    const uint32_t m_MemoryTypeIndex;
+    const VkDeviceSize m_PreferredBlockSize;
+    const size_t m_MinBlockCount;
+    const size_t m_MaxBlockCount;
+    const VkDeviceSize m_BufferImageGranularity;
+    const bool m_ExplicitBlockSize;
+    const uint32_t m_Algorithm;
+    const float m_Priority;
+    const VkDeviceSize m_MinAllocationAlignment;
+
+    void* const m_pMemoryAllocateNext;
+    VMA_RW_MUTEX m_Mutex;
+    // Incrementally sorted by sumFreeSize, ascending.
+    VmaVector<VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*>> m_Blocks;
+    uint32_t m_NextBlockId;
+    bool m_IncrementalSort = true;
+
+    void SetIncrementalSort(bool val) { m_IncrementalSort = val; }
+
+    VkDeviceSize CalcMaxBlockSize() const;
+    // Finds and removes given block from vector.
+    void Remove(VmaDeviceMemoryBlock* pBlock);
+    // Performs single step in sorting m_Blocks. They may not be fully sorted
+    // after this call.
+    void IncrementallySortBlocks();
+    void SortByFreeSize();
+
+    VkResult AllocatePage(
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        const VmaAllocationCreateInfo& createInfo,
+        VmaSuballocationType suballocType,
+        VmaAllocation* pAllocation);
+
+    VkResult AllocateFromBlock(
+        VmaDeviceMemoryBlock* pBlock,
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        VmaAllocationCreateFlags allocFlags,
+        void* pUserData,
+        VmaSuballocationType suballocType,
+        uint32_t strategy,
+        VmaAllocation* pAllocation);
+
+    VkResult CommitAllocationRequest(
+        VmaAllocationRequest& allocRequest,
+        VmaDeviceMemoryBlock* pBlock,
+        VkDeviceSize alignment,
+        VmaAllocationCreateFlags allocFlags,
+        void* pUserData,
+        VmaSuballocationType suballocType,
+        VmaAllocation* pAllocation);
+
+    VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
+    bool HasEmptyBlock();
+};
+#endif // _VMA_BLOCK_VECTOR
+
+#ifndef _VMA_DEFRAGMENTATION_CONTEXT
+struct VmaDefragmentationContext_T
+{
+    VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)
+public:
+    VmaDefragmentationContext_T(
+        VmaAllocator hAllocator,
+        const VmaDefragmentationInfo& info);
+    ~VmaDefragmentationContext_T();
+
+    void GetStats(VmaDefragmentationStats& outStats) { outStats = m_GlobalStats; }
+
+    VkResult DefragmentPassBegin(VmaDefragmentationPassMoveInfo& moveInfo);
+    VkResult DefragmentPassEnd(VmaDefragmentationPassMoveInfo& moveInfo);
+
+private:
+    // Max number of allocations to ignore due to size constraints before ending single pass
+    static const uint8_t MAX_ALLOCS_TO_IGNORE = 16;
+    enum class CounterStatus { Pass, Ignore, End };
+
+    struct FragmentedBlock
+    {
+        uint32_t data;
+        VmaDeviceMemoryBlock* block;
+    };
+    struct StateBalanced
+    {
+        VkDeviceSize avgFreeSize = 0;
+        VkDeviceSize avgAllocSize = UINT64_MAX;
+    };
+    struct StateExtensive
+    {
+        enum class Operation : uint8_t
+        {
+            FindFreeBlockBuffer, FindFreeBlockTexture, FindFreeBlockAll,
+            MoveBuffers, MoveTextures, MoveAll,
+            Cleanup, Done
+        };
+
+        Operation operation = Operation::FindFreeBlockTexture;
+        size_t firstFreeBlock = SIZE_MAX;
+    };
+    struct MoveAllocationData
+    {
+        VkDeviceSize size;
+        VkDeviceSize alignment;
+        VmaSuballocationType type;
+        VmaAllocationCreateFlags flags;
+        VmaDefragmentationMove move = {};
+    };
+
+    const VkDeviceSize m_MaxPassBytes;
+    const uint32_t m_MaxPassAllocations;
+
+    VmaStlAllocator<VmaDefragmentationMove> m_MoveAllocator;
+    VmaVector<VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove>> m_Moves;
+
+    uint8_t m_IgnoredAllocs = 0;
+    uint32_t m_Algorithm;
+    uint32_t m_BlockVectorCount;
+    VmaBlockVector* m_PoolBlockVector;
+    VmaBlockVector** m_pBlockVectors;
+    size_t m_ImmovableBlockCount = 0;
+    VmaDefragmentationStats m_GlobalStats = { 0 };
+    VmaDefragmentationStats m_PassStats = { 0 };
+    void* m_AlgorithmState = VMA_NULL;
+
+    static MoveAllocationData GetMoveData(VmaAllocHandle handle, VmaBlockMetadata* metadata);
+    CounterStatus CheckCounters(VkDeviceSize bytes);
+    bool IncrementCounters(VkDeviceSize bytes);
+    bool ReallocWithinBlock(VmaBlockVector& vector, VmaDeviceMemoryBlock* block);
+    bool AllocInOtherBlock(size_t start, size_t end, MoveAllocationData& data, VmaBlockVector& vector);
+
+    bool ComputeDefragmentation(VmaBlockVector& vector, size_t index);
+    bool ComputeDefragmentation_Fast(VmaBlockVector& vector);
+    bool ComputeDefragmentation_Balanced(VmaBlockVector& vector, size_t index, bool update);
+    bool ComputeDefragmentation_Full(VmaBlockVector& vector);
+    bool ComputeDefragmentation_Extensive(VmaBlockVector& vector, size_t index);
+
+    void UpdateVectorStatistics(VmaBlockVector& vector, StateBalanced& state);
+    bool MoveDataToFreeBlocks(VmaSuballocationType currentType,
+        VmaBlockVector& vector, size_t firstFreeBlock,
+        bool& texturePresent, bool& bufferPresent, bool& otherPresent);
+};
+#endif // _VMA_DEFRAGMENTATION_CONTEXT
+
+#ifndef _VMA_POOL_T
+struct VmaPool_T
+{
+    friend struct VmaPoolListItemTraits;
+    VMA_CLASS_NO_COPY(VmaPool_T)
+public:
+    VmaBlockVector m_BlockVector;
+    VmaDedicatedAllocationList m_DedicatedAllocations;
+
+    VmaPool_T(
+        VmaAllocator hAllocator,
+        const VmaPoolCreateInfo& createInfo,
+        VkDeviceSize preferredBlockSize);
+    ~VmaPool_T();
+
+    uint32_t GetId() const { return m_Id; }
+    void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
+
+    const char* GetName() const { return m_Name; }
+    void SetName(const char* pName);
+
+#if VMA_STATS_STRING_ENABLED
+    //void PrintDetailedMap(class VmaStringBuilder& sb);
+#endif
+
+private:
+    uint32_t m_Id;
+    char* m_Name;
+    VmaPool_T* m_PrevPool = VMA_NULL;
+    VmaPool_T* m_NextPool = VMA_NULL;
+};
+
+struct VmaPoolListItemTraits
+{
+    typedef VmaPool_T ItemType;
+
+    static ItemType* GetPrev(const ItemType* item) { return item->m_PrevPool; }
+    static ItemType* GetNext(const ItemType* item) { return item->m_NextPool; }
+    static ItemType*& AccessPrev(ItemType* item) { return item->m_PrevPool; }
+    static ItemType*& AccessNext(ItemType* item) { return item->m_NextPool; }
+};
+#endif // _VMA_POOL_T
+
+#ifndef _VMA_CURRENT_BUDGET_DATA
+struct VmaCurrentBudgetData
+{
+    VMA_ATOMIC_UINT32 m_BlockCount[VK_MAX_MEMORY_HEAPS];
+    VMA_ATOMIC_UINT32 m_AllocationCount[VK_MAX_MEMORY_HEAPS];
+    VMA_ATOMIC_UINT64 m_BlockBytes[VK_MAX_MEMORY_HEAPS];
+    VMA_ATOMIC_UINT64 m_AllocationBytes[VK_MAX_MEMORY_HEAPS];
+
+#if VMA_MEMORY_BUDGET
+    VMA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch;
+    VMA_RW_MUTEX m_BudgetMutex;
+    uint64_t m_VulkanUsage[VK_MAX_MEMORY_HEAPS];
+    uint64_t m_VulkanBudget[VK_MAX_MEMORY_HEAPS];
+    uint64_t m_BlockBytesAtBudgetFetch[VK_MAX_MEMORY_HEAPS];
+#endif // VMA_MEMORY_BUDGET
+
+    VmaCurrentBudgetData();
+
+    void AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize);
+    void RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize);
+};
+
+#ifndef _VMA_CURRENT_BUDGET_DATA_FUNCTIONS
+VmaCurrentBudgetData::VmaCurrentBudgetData()
+{
+    for (uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)
+    {
+        m_BlockCount[heapIndex] = 0;
+        m_AllocationCount[heapIndex] = 0;
+        m_BlockBytes[heapIndex] = 0;
+        m_AllocationBytes[heapIndex] = 0;
+#if VMA_MEMORY_BUDGET
+        m_VulkanUsage[heapIndex] = 0;
+        m_VulkanBudget[heapIndex] = 0;
+        m_BlockBytesAtBudgetFetch[heapIndex] = 0;
+#endif
+    }
+
+#if VMA_MEMORY_BUDGET
+    m_OperationsSinceBudgetFetch = 0;
+#endif
+}
+
+void VmaCurrentBudgetData::AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
+{
+    m_AllocationBytes[heapIndex] += allocationSize;
+    ++m_AllocationCount[heapIndex];
+#if VMA_MEMORY_BUDGET
+    ++m_OperationsSinceBudgetFetch;
+#endif
+}
+
+void VmaCurrentBudgetData::RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
+{
+    VMA_ASSERT(m_AllocationBytes[heapIndex] >= allocationSize);
+    m_AllocationBytes[heapIndex] -= allocationSize;
+    VMA_ASSERT(m_AllocationCount[heapIndex] > 0);
+    --m_AllocationCount[heapIndex];
+#if VMA_MEMORY_BUDGET
+    ++m_OperationsSinceBudgetFetch;
+#endif
+}
+#endif // _VMA_CURRENT_BUDGET_DATA_FUNCTIONS
+#endif // _VMA_CURRENT_BUDGET_DATA
+
+#ifndef _VMA_ALLOCATION_OBJECT_ALLOCATOR
+/*
+Thread-safe wrapper over VmaPoolAllocator free list, for allocation of VmaAllocation_T objects.
+*/
+class VmaAllocationObjectAllocator
+{
+    VMA_CLASS_NO_COPY(VmaAllocationObjectAllocator)
+public:
+    VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks)
+        : m_Allocator(pAllocationCallbacks, 1024) {}
+
+    template<typename... Types> VmaAllocation Allocate(Types&&... args);
+    void Free(VmaAllocation hAlloc);
+
+private:
+    VMA_MUTEX m_Mutex;
+    VmaPoolAllocator<VmaAllocation_T> m_Allocator;
+};
+
+template<typename... Types>
+VmaAllocation VmaAllocationObjectAllocator::Allocate(Types&&... args)
+{
+    VmaMutexLock mutexLock(m_Mutex);
+    return m_Allocator.Alloc<Types...>(std::forward<Types>(args)...);
+}
+
+void VmaAllocationObjectAllocator::Free(VmaAllocation hAlloc)
+{
+    VmaMutexLock mutexLock(m_Mutex);
+    m_Allocator.Free(hAlloc);
+}
+#endif // _VMA_ALLOCATION_OBJECT_ALLOCATOR
+
+#ifndef _VMA_VIRTUAL_BLOCK_T
+struct VmaVirtualBlock_T
+{
+    VMA_CLASS_NO_COPY(VmaVirtualBlock_T)
+public:
+    const bool m_AllocationCallbacksSpecified;
+    const VkAllocationCallbacks m_AllocationCallbacks;
+
+    VmaVirtualBlock_T(const VmaVirtualBlockCreateInfo& createInfo);
+    ~VmaVirtualBlock_T();
+
+    VkResult Init() { return VK_SUCCESS; }
+    bool IsEmpty() const { return m_Metadata->IsEmpty(); }
+    void Free(VmaVirtualAllocation allocation) { m_Metadata->Free((VmaAllocHandle)allocation); }
+    void SetAllocationUserData(VmaVirtualAllocation allocation, void* userData) { m_Metadata->SetAllocationUserData((VmaAllocHandle)allocation, userData); }
+    void Clear() { m_Metadata->Clear(); }
+
+    const VkAllocationCallbacks* GetAllocationCallbacks() const;
+    void GetAllocationInfo(VmaVirtualAllocation allocation, VmaVirtualAllocationInfo& outInfo);
+    VkResult Allocate(const VmaVirtualAllocationCreateInfo& createInfo, VmaVirtualAllocation& outAllocation,
+        VkDeviceSize* outOffset);
+    void GetStatistics(VmaStatistics& outStats) const;
+    void CalculateDetailedStatistics(VmaDetailedStatistics& outStats) const;
+#if VMA_STATS_STRING_ENABLED
+    void BuildStatsString(bool detailedMap, VmaStringBuilder& sb) const;
+#endif
+
+private:
+    VmaBlockMetadata* m_Metadata;
+};
+
+#ifndef _VMA_VIRTUAL_BLOCK_T_FUNCTIONS
+VmaVirtualBlock_T::VmaVirtualBlock_T(const VmaVirtualBlockCreateInfo& createInfo)
+    : m_AllocationCallbacksSpecified(createInfo.pAllocationCallbacks != VMA_NULL),
+    m_AllocationCallbacks(createInfo.pAllocationCallbacks != VMA_NULL ? *createInfo.pAllocationCallbacks : VmaEmptyAllocationCallbacks)
+{
+    const uint32_t algorithm = createInfo.flags & VMA_VIRTUAL_BLOCK_CREATE_ALGORITHM_MASK;
+    switch (algorithm)
+    {
+    default:
+        VMA_ASSERT(0);
+    case 0:
+        m_Metadata = vma_new(GetAllocationCallbacks(), VmaBlockMetadata_TLSF)(VK_NULL_HANDLE, 1, true);
+        break;
+    case VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT:
+        m_Metadata = vma_new(GetAllocationCallbacks(), VmaBlockMetadata_Linear)(VK_NULL_HANDLE, 1, true);
+        break;
+    }
+
+    m_Metadata->Init(createInfo.size);
+}
+
+VmaVirtualBlock_T::~VmaVirtualBlock_T()
+{
+    // Define macro VMA_DEBUG_LOG to receive the list of the unfreed allocations
+    if (!m_Metadata->IsEmpty())
+        m_Metadata->DebugLogAllAllocations();
+    // This is the most important assert in the entire library.
+    // Hitting it means you have some memory leak - unreleased virtual allocations.
+    VMA_ASSERT(m_Metadata->IsEmpty() && "Some virtual allocations were not freed before destruction of this virtual block!");
+
+    vma_delete(GetAllocationCallbacks(), m_Metadata);
+}
+
+const VkAllocationCallbacks* VmaVirtualBlock_T::GetAllocationCallbacks() const
+{
+    return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : VMA_NULL;
+}
+
+void VmaVirtualBlock_T::GetAllocationInfo(VmaVirtualAllocation allocation, VmaVirtualAllocationInfo& outInfo)
+{
+    m_Metadata->GetAllocationInfo((VmaAllocHandle)allocation, outInfo);
+}
+
+VkResult VmaVirtualBlock_T::Allocate(const VmaVirtualAllocationCreateInfo& createInfo, VmaVirtualAllocation& outAllocation,
+    VkDeviceSize* outOffset)
+{
+    VmaAllocationRequest request = {};
+    if (m_Metadata->CreateAllocationRequest(
+        createInfo.size, // allocSize
+        VMA_MAX(createInfo.alignment, (VkDeviceSize)1), // allocAlignment
+        (createInfo.flags & VMA_VIRTUAL_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0, // upperAddress
+        VMA_SUBALLOCATION_TYPE_UNKNOWN, // allocType - unimportant
+        createInfo.flags & VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MASK, // strategy
+        &request))
+    {
+        m_Metadata->Alloc(request,
+            VMA_SUBALLOCATION_TYPE_UNKNOWN, // type - unimportant
+            createInfo.pUserData);
+        outAllocation = (VmaVirtualAllocation)request.allocHandle;
+        if(outOffset)
+            *outOffset = m_Metadata->GetAllocationOffset(request.allocHandle);
+        return VK_SUCCESS;
+    }
+    outAllocation = (VmaVirtualAllocation)VK_NULL_HANDLE;
+    if (outOffset)
+        *outOffset = UINT64_MAX;
+    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+}
+
+void VmaVirtualBlock_T::GetStatistics(VmaStatistics& outStats) const
+{
+    VmaClearStatistics(outStats);
+    m_Metadata->AddStatistics(outStats);
+}
+
+void VmaVirtualBlock_T::CalculateDetailedStatistics(VmaDetailedStatistics& outStats) const
+{
+    VmaClearDetailedStatistics(outStats);
+    m_Metadata->AddDetailedStatistics(outStats);
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaVirtualBlock_T::BuildStatsString(bool detailedMap, VmaStringBuilder& sb) const
+{
+    VmaJsonWriter json(GetAllocationCallbacks(), sb);
+    json.BeginObject();
+
+    VmaDetailedStatistics stats;
+    CalculateDetailedStatistics(stats);
+
+    json.WriteString("Stats");
+    VmaPrintDetailedStatistics(json, stats);
+
+    if (detailedMap)
+    {
+        json.WriteString("Details");
+        json.BeginObject();
+        m_Metadata->PrintDetailedMap(json);
+        json.EndObject();
+    }
+
+    json.EndObject();
+}
+#endif // VMA_STATS_STRING_ENABLED
+#endif // _VMA_VIRTUAL_BLOCK_T_FUNCTIONS
+#endif // _VMA_VIRTUAL_BLOCK_T
+
+
+// Main allocator object.
+struct VmaAllocator_T
+{
+    VMA_CLASS_NO_COPY(VmaAllocator_T)
+public:
+    bool m_UseMutex;
+    uint32_t m_VulkanApiVersion;
+    bool m_UseKhrDedicatedAllocation; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
+    bool m_UseKhrBindMemory2; // Can be set only if m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0).
+    bool m_UseExtMemoryBudget;
+    bool m_UseAmdDeviceCoherentMemory;
+    bool m_UseKhrBufferDeviceAddress;
+    bool m_UseExtMemoryPriority;
+    VkDevice m_hDevice;
+    VkInstance m_hInstance;
+    bool m_AllocationCallbacksSpecified;
+    VkAllocationCallbacks m_AllocationCallbacks;
+    VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
+    VmaAllocationObjectAllocator m_AllocationObjectAllocator;
+
+    // Each bit (1 << i) is set if HeapSizeLimit is enabled for that heap, so cannot allocate more than the heap size.
+    uint32_t m_HeapSizeLimitMask;
+
+    VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
+    VkPhysicalDeviceMemoryProperties m_MemProps;
+
+    // Default pools.
+    VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
+    VmaDedicatedAllocationList m_DedicatedAllocations[VK_MAX_MEMORY_TYPES];
+
+    VmaCurrentBudgetData m_Budget;
+    VMA_ATOMIC_UINT32 m_DeviceMemoryCount; // Total number of VkDeviceMemory objects.
+
+    VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
+    VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
+    ~VmaAllocator_T();
+
+    const VkAllocationCallbacks* GetAllocationCallbacks() const
+    {
+        return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : VMA_NULL;
+    }
+    const VmaVulkanFunctions& GetVulkanFunctions() const
+    {
+        return m_VulkanFunctions;
+    }
+
+    VkPhysicalDevice GetPhysicalDevice() const { return m_PhysicalDevice; }
+
+    VkDeviceSize GetBufferImageGranularity() const
+    {
+        return VMA_MAX(
+            static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
+            m_PhysicalDeviceProperties.limits.bufferImageGranularity);
+    }
+
+    uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
+    uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
+
+    uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
+    {
+        VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
+        return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
+    }
+    // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
+    bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
+    {
+        return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+    }
+    // Minimum alignment for all allocations in specific memory type.
+    VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
+    {
+        return IsMemoryTypeNonCoherent(memTypeIndex) ?
+            VMA_MAX((VkDeviceSize)VMA_MIN_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
+            (VkDeviceSize)VMA_MIN_ALIGNMENT;
+    }
+
+    bool IsIntegratedGpu() const
+    {
+        return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+    }
+
+    uint32_t GetGlobalMemoryTypeBits() const { return m_GlobalMemoryTypeBits; }
+
+    void GetBufferMemoryRequirements(
+        VkBuffer hBuffer,
+        VkMemoryRequirements& memReq,
+        bool& requiresDedicatedAllocation,
+        bool& prefersDedicatedAllocation) const;
+    void GetImageMemoryRequirements(
+        VkImage hImage,
+        VkMemoryRequirements& memReq,
+        bool& requiresDedicatedAllocation,
+        bool& prefersDedicatedAllocation) const;
+    VkResult FindMemoryTypeIndex(
+        uint32_t memoryTypeBits,
+        const VmaAllocationCreateInfo* pAllocationCreateInfo,
+        VkFlags bufImgUsage, // VkBufferCreateInfo::usage or VkImageCreateInfo::usage. UINT32_MAX if unknown.
+        uint32_t* pMemoryTypeIndex) const;
+
+    // Main allocation function.
+    VkResult AllocateMemory(
+        const VkMemoryRequirements& vkMemReq,
+        bool requiresDedicatedAllocation,
+        bool prefersDedicatedAllocation,
+        VkBuffer dedicatedBuffer,
+        VkImage dedicatedImage,
+        VkFlags dedicatedBufferImageUsage, // UINT32_MAX if unknown.
+        const VmaAllocationCreateInfo& createInfo,
+        VmaSuballocationType suballocType,
+        size_t allocationCount,
+        VmaAllocation* pAllocations);
+
+    // Main deallocation function.
+    void FreeMemory(
+        size_t allocationCount,
+        const VmaAllocation* pAllocations);
+
+    void CalculateStatistics(VmaTotalStatistics* pStats);
+
+    void GetHeapBudgets(
+        VmaBudget* outBudgets, uint32_t firstHeap, uint32_t heapCount);
+
+#if VMA_STATS_STRING_ENABLED
+    void PrintDetailedMap(class VmaJsonWriter& json);
+#endif
+
+    void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
+
+    VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
+    void DestroyPool(VmaPool pool);
+    void GetPoolStatistics(VmaPool pool, VmaStatistics* pPoolStats);
+    void CalculatePoolStatistics(VmaPool pool, VmaDetailedStatistics* pPoolStats);
+
+    void SetCurrentFrameIndex(uint32_t frameIndex);
+    uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
+
+    VkResult CheckPoolCorruption(VmaPool hPool);
+    VkResult CheckCorruption(uint32_t memoryTypeBits);
+
+    // Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
+    VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
+    // Call to Vulkan function vkFreeMemory with accompanying bookkeeping.
+    void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
+    // Call to Vulkan function vkBindBufferMemory or vkBindBufferMemory2KHR.
+    VkResult BindVulkanBuffer(
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset,
+        VkBuffer buffer,
+        const void* pNext);
+    // Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
+    VkResult BindVulkanImage(
+        VkDeviceMemory memory,
+        VkDeviceSize memoryOffset,
+        VkImage image,
+        const void* pNext);
+
+    VkResult Map(VmaAllocation hAllocation, void** ppData);
+    void Unmap(VmaAllocation hAllocation);
+
+    VkResult BindBufferMemory(
+        VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkBuffer hBuffer,
+        const void* pNext);
+    VkResult BindImageMemory(
+        VmaAllocation hAllocation,
+        VkDeviceSize allocationLocalOffset,
+        VkImage hImage,
+        const void* pNext);
+
+    VkResult FlushOrInvalidateAllocation(
+        VmaAllocation hAllocation,
+        VkDeviceSize offset, VkDeviceSize size,
+        VMA_CACHE_OPERATION op);
+    VkResult FlushOrInvalidateAllocations(
+        uint32_t allocationCount,
+        const VmaAllocation* allocations,
+        const VkDeviceSize* offsets, const VkDeviceSize* sizes,
+        VMA_CACHE_OPERATION op);
+
+    void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
+
+    /*
+    Returns bit mask of memory types that can support defragmentation on GPU as
+    they support creation of required buffer for copy operations.
+    */
+    uint32_t GetGpuDefragmentationMemoryTypeBits();
+
+#if VMA_EXTERNAL_MEMORY
+    VkExternalMemoryHandleTypeFlagsKHR GetExternalMemoryHandleTypeFlags(uint32_t memTypeIndex) const
+    {
+        return m_TypeExternalMemoryHandleTypes[memTypeIndex];
+    }
+#endif // #if VMA_EXTERNAL_MEMORY
+
+private:
+    VkDeviceSize m_PreferredLargeHeapBlockSize;
+
+    VkPhysicalDevice m_PhysicalDevice;
+    VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
+    VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.
+#if VMA_EXTERNAL_MEMORY
+    VkExternalMemoryHandleTypeFlagsKHR m_TypeExternalMemoryHandleTypes[VK_MAX_MEMORY_TYPES];
+#endif // #if VMA_EXTERNAL_MEMORY
+
+    VMA_RW_MUTEX m_PoolsMutex;
+    typedef VmaIntrusiveLinkedList<VmaPoolListItemTraits> PoolList;
+    // Protected by m_PoolsMutex.
+    PoolList m_Pools;
+    uint32_t m_NextPoolId;
+
+    VmaVulkanFunctions m_VulkanFunctions;
+
+    // Global bit mask AND-ed with any memoryTypeBits to disallow certain memory types.
+    uint32_t m_GlobalMemoryTypeBits;
+
+    void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
+
+#if VMA_STATIC_VULKAN_FUNCTIONS == 1
+    void ImportVulkanFunctions_Static();
+#endif
+
+    void ImportVulkanFunctions_Custom(const VmaVulkanFunctions* pVulkanFunctions);
+
+#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+    void ImportVulkanFunctions_Dynamic();
+#endif
+
+    void ValidateVulkanFunctions();
+
+    VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
+
+    VkResult AllocateMemoryOfType(
+        VmaPool pool,
+        VkDeviceSize size,
+        VkDeviceSize alignment,
+        bool dedicatedPreferred,
+        VkBuffer dedicatedBuffer,
+        VkImage dedicatedImage,
+        VkFlags dedicatedBufferImageUsage,
+        const VmaAllocationCreateInfo& createInfo,
+        uint32_t memTypeIndex,
+        VmaSuballocationType suballocType,
+        VmaDedicatedAllocationList& dedicatedAllocations,
+        VmaBlockVector& blockVector,
+        size_t allocationCount,
+        VmaAllocation* pAllocations);
+
+    // Helper function only to be used inside AllocateDedicatedMemory.
+    VkResult AllocateDedicatedMemoryPage(
+        VmaPool pool,
+        VkDeviceSize size,
+        VmaSuballocationType suballocType,
+        uint32_t memTypeIndex,
+        const VkMemoryAllocateInfo& allocInfo,
+        bool map,
+        bool isUserDataString,
+        bool isMappingAllowed,
+        void* pUserData,
+        VmaAllocation* pAllocation);
+
+    // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.
+    VkResult AllocateDedicatedMemory(
+        VmaPool pool,
+        VkDeviceSize size,
+        VmaSuballocationType suballocType,
+        VmaDedicatedAllocationList& dedicatedAllocations,
+        uint32_t memTypeIndex,
+        bool map,
+        bool isUserDataString,
+        bool isMappingAllowed,
+        bool canAliasMemory,
+        void* pUserData,
+        float priority,
+        VkBuffer dedicatedBuffer,
+        VkImage dedicatedImage,
+        VkFlags dedicatedBufferImageUsage,
+        size_t allocationCount,
+        VmaAllocation* pAllocations,
+        const void* pNextChain = nullptr);
+
+    void FreeDedicatedMemory(const VmaAllocation allocation);
+
+    VkResult CalcMemTypeParams(
+        VmaAllocationCreateInfo& outCreateInfo,
+        uint32_t memTypeIndex,
+        VkDeviceSize size,
+        size_t allocationCount);
+    VkResult CalcAllocationParams(
+        VmaAllocationCreateInfo& outCreateInfo,
+        bool dedicatedRequired,
+        bool dedicatedPreferred);
+
+    /*
+    Calculates and returns bit mask of memory types that can support defragmentation
+    on GPU as they support creation of required buffer for copy operations.
+    */
+    uint32_t CalculateGpuDefragmentationMemoryTypeBits() const;
+    uint32_t CalculateGlobalMemoryTypeBits() const;
+
+    bool GetFlushOrInvalidateRange(
+        VmaAllocation allocation,
+        VkDeviceSize offset, VkDeviceSize size,
+        VkMappedMemoryRange& outRange) const;
+
+#if VMA_MEMORY_BUDGET
+    void UpdateVulkanBudget();
+#endif // #if VMA_MEMORY_BUDGET
+};
+
+
+#ifndef _VMA_MEMORY_FUNCTIONS
+static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
+{
+    return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
+}
+
+static void VmaFree(VmaAllocator hAllocator, void* ptr)
+{
+    VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
+}
+
+template<typename T>
+static T* VmaAllocate(VmaAllocator hAllocator)
+{
+    return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
+}
+
+template<typename T>
+static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
+{
+    return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
+}
+
+template<typename T>
+static void vma_delete(VmaAllocator hAllocator, T* ptr)
+{
+    if(ptr != VMA_NULL)
+    {
+        ptr->~T();
+        VmaFree(hAllocator, ptr);
+    }
+}
+
+template<typename T>
+static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
+{
+    if(ptr != VMA_NULL)
+    {
+        for(size_t i = count; i--; )
+            ptr[i].~T();
+        VmaFree(hAllocator, ptr);
+    }
+}
+#endif // _VMA_MEMORY_FUNCTIONS
+
+#ifndef _VMA_DEVICE_MEMORY_BLOCK_FUNCTIONS
+VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator)
+    : m_pMetadata(VMA_NULL),
+    m_MemoryTypeIndex(UINT32_MAX),
+    m_Id(0),
+    m_hMemory(VK_NULL_HANDLE),
+    m_MapCount(0),
+    m_pMappedData(VMA_NULL) {}
+
+VmaDeviceMemoryBlock::~VmaDeviceMemoryBlock()
+{
+    VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
+    VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
+}
+
+void VmaDeviceMemoryBlock::Init(
+    VmaAllocator hAllocator,
+    VmaPool hParentPool,
+    uint32_t newMemoryTypeIndex,
+    VkDeviceMemory newMemory,
+    VkDeviceSize newSize,
+    uint32_t id,
+    uint32_t algorithm,
+    VkDeviceSize bufferImageGranularity)
+{
+    VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
+
+    m_hParentPool = hParentPool;
+    m_MemoryTypeIndex = newMemoryTypeIndex;
+    m_Id = id;
+    m_hMemory = newMemory;
+
+    switch (algorithm)
+    {
+    case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
+        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator->GetAllocationCallbacks(),
+            bufferImageGranularity, false); // isVirtual
+        break;
+    default:
+        VMA_ASSERT(0);
+        // Fall-through.
+    case 0:
+        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_TLSF)(hAllocator->GetAllocationCallbacks(),
+            bufferImageGranularity, false); // isVirtual
+    }
+    m_pMetadata->Init(newSize);
+}
+
+void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
+{
+    // Define macro VMA_DEBUG_LOG to receive the list of the unfreed allocations
+    if (!m_pMetadata->IsEmpty())
+        m_pMetadata->DebugLogAllAllocations();
+    // This is the most important assert in the entire library.
+    // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
+    VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
+
+    VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
+    allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
+    m_hMemory = VK_NULL_HANDLE;
+
+    vma_delete(allocator, m_pMetadata);
+    m_pMetadata = VMA_NULL;
+}
+
+void VmaDeviceMemoryBlock::PostFree(VmaAllocator hAllocator)
+{
+    if(m_MappingHysteresis.PostFree())
+    {
+        VMA_ASSERT(m_MappingHysteresis.GetExtraMapping() == 0);
+        if (m_MapCount == 0)
+        {
+            m_pMappedData = VMA_NULL;
+            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
+        }
+    }
+}
+
+bool VmaDeviceMemoryBlock::Validate() const
+{
+    VMA_VALIDATE((m_hMemory != VK_NULL_HANDLE) &&
+        (m_pMetadata->GetSize() != 0));
+
+    return m_pMetadata->Validate();
+}
+
+VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
+{
+    void* pData = nullptr;
+    VkResult res = Map(hAllocator, 1, &pData);
+    if (res != VK_SUCCESS)
+    {
+        return res;
+    }
+
+    res = m_pMetadata->CheckCorruption(pData);
+
+    Unmap(hAllocator, 1);
+
+    return res;
+}
+
+VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
+{
+    if (count == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
+    const uint32_t oldTotalMapCount = m_MapCount + m_MappingHysteresis.GetExtraMapping();
+    m_MappingHysteresis.PostMap();
+    if (oldTotalMapCount != 0)
+    {
+        m_MapCount += count;
+        VMA_ASSERT(m_pMappedData != VMA_NULL);
+        if (ppData != VMA_NULL)
+        {
+            *ppData = m_pMappedData;
+        }
+        return VK_SUCCESS;
+    }
+    else
+    {
+        VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
+            hAllocator->m_hDevice,
+            m_hMemory,
+            0, // offset
+            VK_WHOLE_SIZE,
+            0, // flags
+            &m_pMappedData);
+        if (result == VK_SUCCESS)
+        {
+            if (ppData != VMA_NULL)
+            {
+                *ppData = m_pMappedData;
+            }
+            m_MapCount = count;
+        }
+        return result;
+    }
+}
+
+void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
+{
+    if (count == 0)
+    {
+        return;
+    }
+
+    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
+    if (m_MapCount >= count)
+    {
+        m_MapCount -= count;
+        const uint32_t totalMapCount = m_MapCount + m_MappingHysteresis.GetExtraMapping();
+        if (totalMapCount == 0)
+        {
+            m_pMappedData = VMA_NULL;
+            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
+        }
+        m_MappingHysteresis.PostUnmap();
+    }
+    else
+    {
+        VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
+    }
+}
+
+VkResult VmaDeviceMemoryBlock::WriteMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
+{
+    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
+
+    void* pData;
+    VkResult res = Map(hAllocator, 1, &pData);
+    if (res != VK_SUCCESS)
+    {
+        return res;
+    }
+
+    VmaWriteMagicValue(pData, allocOffset + allocSize);
+
+    Unmap(hAllocator, 1);
+    return VK_SUCCESS;
+}
+
+VkResult VmaDeviceMemoryBlock::ValidateMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
+{
+    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
+
+    void* pData;
+    VkResult res = Map(hAllocator, 1, &pData);
+    if (res != VK_SUCCESS)
+    {
+        return res;
+    }
+
+    if (!VmaValidateMagicValue(pData, allocOffset + allocSize))
+    {
+        VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
+    }
+
+    Unmap(hAllocator, 1);
+    return VK_SUCCESS;
+}
+
+VkResult VmaDeviceMemoryBlock::BindBufferMemory(
+    const VmaAllocator hAllocator,
+    const VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer hBuffer,
+    const void* pNext)
+{
+    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
+        hAllocation->GetBlock() == this);
+    VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
+        "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
+    const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
+    // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
+    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
+    return hAllocator->BindVulkanBuffer(m_hMemory, memoryOffset, hBuffer, pNext);
+}
+
+VkResult VmaDeviceMemoryBlock::BindImageMemory(
+    const VmaAllocator hAllocator,
+    const VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage hImage,
+    const void* pNext)
+{
+    VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
+        hAllocation->GetBlock() == this);
+    VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
+        "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
+    const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
+    // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
+    VmaMutexLock lock(m_MapAndBindMutex, hAllocator->m_UseMutex);
+    return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
+}
+#endif // _VMA_DEVICE_MEMORY_BLOCK_FUNCTIONS
+
+#ifndef _VMA_ALLOCATION_T_FUNCTIONS
+VmaAllocation_T::VmaAllocation_T(bool mappingAllowed)
+    : m_Alignment{ 1 },
+    m_Size{ 0 },
+    m_pUserData{ VMA_NULL },
+    m_pName{ VMA_NULL },
+    m_MemoryTypeIndex{ 0 },
+    m_Type{ (uint8_t)ALLOCATION_TYPE_NONE },
+    m_SuballocationType{ (uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN },
+    m_MapCount{ 0 },
+    m_Flags{ 0 }
+{
+    if(mappingAllowed)
+        m_Flags |= (uint8_t)FLAG_MAPPING_ALLOWED;
+
+#if VMA_STATS_STRING_ENABLED
+    m_BufferImageUsage = 0;
+#endif
+}
+
+VmaAllocation_T::~VmaAllocation_T()
+{
+    VMA_ASSERT(m_MapCount == 0 && "Allocation was not unmapped before destruction.");
+
+    // Check if owned string was freed.
+    VMA_ASSERT(m_pName == VMA_NULL);
+}
+
+void VmaAllocation_T::InitBlockAllocation(
+    VmaDeviceMemoryBlock* block,
+    VmaAllocHandle allocHandle,
+    VkDeviceSize alignment,
+    VkDeviceSize size,
+    uint32_t memoryTypeIndex,
+    VmaSuballocationType suballocationType,
+    bool mapped)
+{
+    VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
+    VMA_ASSERT(block != VMA_NULL);
+    m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
+    m_Alignment = alignment;
+    m_Size = size;
+    m_MemoryTypeIndex = memoryTypeIndex;
+    if(mapped)
+    {
+        VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");
+        m_Flags |= (uint8_t)FLAG_PERSISTENT_MAP;
+    }
+    m_SuballocationType = (uint8_t)suballocationType;
+    m_BlockAllocation.m_Block = block;
+    m_BlockAllocation.m_AllocHandle = allocHandle;
+}
+
+void VmaAllocation_T::InitDedicatedAllocation(
+    VmaPool hParentPool,
+    uint32_t memoryTypeIndex,
+    VkDeviceMemory hMemory,
+    VmaSuballocationType suballocationType,
+    void* pMappedData,
+    VkDeviceSize size)
+{
+    VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
+    VMA_ASSERT(hMemory != VK_NULL_HANDLE);
+    m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
+    m_Alignment = 0;
+    m_Size = size;
+    m_MemoryTypeIndex = memoryTypeIndex;
+    m_SuballocationType = (uint8_t)suballocationType;
+    if(pMappedData != VMA_NULL)
+    {
+        VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");
+        m_Flags |= (uint8_t)FLAG_PERSISTENT_MAP;
+    }
+    m_DedicatedAllocation.m_hParentPool = hParentPool;
+    m_DedicatedAllocation.m_hMemory = hMemory;
+    m_DedicatedAllocation.m_pMappedData = pMappedData;
+    m_DedicatedAllocation.m_Prev = VMA_NULL;
+    m_DedicatedAllocation.m_Next = VMA_NULL;
+}
+
+void VmaAllocation_T::SetName(VmaAllocator hAllocator, const char* pName)
+{
+    VMA_ASSERT(pName == VMA_NULL || pName != m_pName);
+
+    FreeName(hAllocator);
+
+    if (pName != VMA_NULL)
+        m_pName = VmaCreateStringCopy(hAllocator->GetAllocationCallbacks(), pName);
+}
+
+uint8_t VmaAllocation_T::SwapBlockAllocation(VmaAllocator hAllocator, VmaAllocation allocation)
+{
+    VMA_ASSERT(allocation != VMA_NULL);
+    VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
+    VMA_ASSERT(allocation->m_Type == ALLOCATION_TYPE_BLOCK);
+
+    if (m_MapCount != 0)
+        m_BlockAllocation.m_Block->Unmap(hAllocator, m_MapCount);
+
+    m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, allocation);
+    VMA_SWAP(m_BlockAllocation, allocation->m_BlockAllocation);
+    m_BlockAllocation.m_Block->m_pMetadata->SetAllocationUserData(m_BlockAllocation.m_AllocHandle, this);
+
+#if VMA_STATS_STRING_ENABLED
+    VMA_SWAP(m_BufferImageUsage, allocation->m_BufferImageUsage);
+#endif
+    return m_MapCount;
+}
+
+VmaAllocHandle VmaAllocation_T::GetAllocHandle() const
+{
+    switch (m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        return m_BlockAllocation.m_AllocHandle;
+    case ALLOCATION_TYPE_DEDICATED:
+        return VK_NULL_HANDLE;
+    default:
+        VMA_ASSERT(0);
+        return VK_NULL_HANDLE;
+    }
+}
+
+VkDeviceSize VmaAllocation_T::GetOffset() const
+{
+    switch (m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        return m_BlockAllocation.m_Block->m_pMetadata->GetAllocationOffset(m_BlockAllocation.m_AllocHandle);
+    case ALLOCATION_TYPE_DEDICATED:
+        return 0;
+    default:
+        VMA_ASSERT(0);
+        return 0;
+    }
+}
+
+VmaPool VmaAllocation_T::GetParentPool() const
+{
+    switch (m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        return m_BlockAllocation.m_Block->GetParentPool();
+    case ALLOCATION_TYPE_DEDICATED:
+        return m_DedicatedAllocation.m_hParentPool;
+    default:
+        VMA_ASSERT(0);
+        return VK_NULL_HANDLE;
+    }
+}
+
+VkDeviceMemory VmaAllocation_T::GetMemory() const
+{
+    switch (m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        return m_BlockAllocation.m_Block->GetDeviceMemory();
+    case ALLOCATION_TYPE_DEDICATED:
+        return m_DedicatedAllocation.m_hMemory;
+    default:
+        VMA_ASSERT(0);
+        return VK_NULL_HANDLE;
+    }
+}
+
+void* VmaAllocation_T::GetMappedData() const
+{
+    switch (m_Type)
+    {
+    case ALLOCATION_TYPE_BLOCK:
+        if (m_MapCount != 0 || IsPersistentMap())
+        {
+            void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
+            VMA_ASSERT(pBlockData != VMA_NULL);
+            return (char*)pBlockData + GetOffset();
+        }
+        else
+        {
+            return VMA_NULL;
+        }
+        break;
+    case ALLOCATION_TYPE_DEDICATED:
+        VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0 || IsPersistentMap()));
+        return m_DedicatedAllocation.m_pMappedData;
+    default:
+        VMA_ASSERT(0);
+        return VMA_NULL;
+    }
+}
+
+void VmaAllocation_T::BlockAllocMap()
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
+    VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");
+
+    if (m_MapCount < 0xFF)
+    {
+        ++m_MapCount;
+    }
+    else
+    {
+        VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
+    }
+}
+
+void VmaAllocation_T::BlockAllocUnmap()
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
+
+    if (m_MapCount > 0)
+    {
+        --m_MapCount;
+    }
+    else
+    {
+        VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
+    }
+}
+
+VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
+    VMA_ASSERT(IsMappingAllowed() && "Mapping is not allowed on this allocation! Please use one of the new VMA_ALLOCATION_CREATE_HOST_ACCESS_* flags when creating it.");
+
+    if (m_MapCount != 0 || IsPersistentMap())
+    {
+        if (m_MapCount < 0xFF)
+        {
+            VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
+            *ppData = m_DedicatedAllocation.m_pMappedData;
+            ++m_MapCount;
+            return VK_SUCCESS;
+        }
+        else
+        {
+            VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
+            return VK_ERROR_MEMORY_MAP_FAILED;
+        }
+    }
+    else
+    {
+        VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
+            hAllocator->m_hDevice,
+            m_DedicatedAllocation.m_hMemory,
+            0, // offset
+            VK_WHOLE_SIZE,
+            0, // flags
+            ppData);
+        if (result == VK_SUCCESS)
+        {
+            m_DedicatedAllocation.m_pMappedData = *ppData;
+            m_MapCount = 1;
+        }
+        return result;
+    }
+}
+
+void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
+{
+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
+
+    if (m_MapCount > 0)
+    {
+        --m_MapCount;
+        if (m_MapCount == 0 && !IsPersistentMap())
+        {
+            m_DedicatedAllocation.m_pMappedData = VMA_NULL;
+            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
+                hAllocator->m_hDevice,
+                m_DedicatedAllocation.m_hMemory);
+        }
+    }
+    else
+    {
+        VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
+    }
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaAllocation_T::InitBufferImageUsage(uint32_t bufferImageUsage)
+{
+    VMA_ASSERT(m_BufferImageUsage == 0);
+    m_BufferImageUsage = bufferImageUsage;
+}
+
+void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
+{
+    json.WriteString("Type");
+    json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
+
+    json.WriteString("Size");
+    json.WriteNumber(m_Size);
+    json.WriteString("Usage");
+    json.WriteNumber(m_BufferImageUsage);
+
+    if (m_pUserData != VMA_NULL)
+    {
+        json.WriteString("CustomData");
+        json.BeginString();
+        json.ContinueString_Pointer(m_pUserData);
+        json.EndString();
+    }
+    if (m_pName != VMA_NULL)
+    {
+        json.WriteString("Name");
+        json.WriteString(m_pName);
+    }
+}
+#endif // VMA_STATS_STRING_ENABLED
+
+void VmaAllocation_T::FreeName(VmaAllocator hAllocator)
+{
+    if(m_pName)
+    {
+        VmaFreeString(hAllocator->GetAllocationCallbacks(), m_pName);
+        m_pName = VMA_NULL;
+    }
+}
+#endif // _VMA_ALLOCATION_T_FUNCTIONS
+
+#ifndef _VMA_BLOCK_VECTOR_FUNCTIONS
+VmaBlockVector::VmaBlockVector(
+    VmaAllocator hAllocator,
+    VmaPool hParentPool,
+    uint32_t memoryTypeIndex,
+    VkDeviceSize preferredBlockSize,
+    size_t minBlockCount,
+    size_t maxBlockCount,
+    VkDeviceSize bufferImageGranularity,
+    bool explicitBlockSize,
+    uint32_t algorithm,
+    float priority,
+    VkDeviceSize minAllocationAlignment,
+    void* pMemoryAllocateNext)
+    : m_hAllocator(hAllocator),
+    m_hParentPool(hParentPool),
+    m_MemoryTypeIndex(memoryTypeIndex),
+    m_PreferredBlockSize(preferredBlockSize),
+    m_MinBlockCount(minBlockCount),
+    m_MaxBlockCount(maxBlockCount),
+    m_BufferImageGranularity(bufferImageGranularity),
+    m_ExplicitBlockSize(explicitBlockSize),
+    m_Algorithm(algorithm),
+    m_Priority(priority),
+    m_MinAllocationAlignment(minAllocationAlignment),
+    m_pMemoryAllocateNext(pMemoryAllocateNext),
+    m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
+    m_NextBlockId(0) {}
+
+VmaBlockVector::~VmaBlockVector()
+{
+    for (size_t i = m_Blocks.size(); i--; )
+    {
+        m_Blocks[i]->Destroy(m_hAllocator);
+        vma_delete(m_hAllocator, m_Blocks[i]);
+    }
+}
+
+VkResult VmaBlockVector::CreateMinBlocks()
+{
+    for (size_t i = 0; i < m_MinBlockCount; ++i)
+    {
+        VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
+        if (res != VK_SUCCESS)
+        {
+            return res;
+        }
+    }
+    return VK_SUCCESS;
+}
+
+void VmaBlockVector::AddStatistics(VmaStatistics& inoutStats)
+{
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+    const size_t blockCount = m_Blocks.size();
+    for (uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
+    {
+        const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
+        VMA_ASSERT(pBlock);
+        VMA_HEAVY_ASSERT(pBlock->Validate());
+        pBlock->m_pMetadata->AddStatistics(inoutStats);
+    }
+}
+
+void VmaBlockVector::AddDetailedStatistics(VmaDetailedStatistics& inoutStats)
+{
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+    const size_t blockCount = m_Blocks.size();
+    for (uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
+    {
+        const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
+        VMA_ASSERT(pBlock);
+        VMA_HEAVY_ASSERT(pBlock->Validate());
+        pBlock->m_pMetadata->AddDetailedStatistics(inoutStats);
+    }
+}
+
+bool VmaBlockVector::IsEmpty()
+{
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+    return m_Blocks.empty();
+}
+
+bool VmaBlockVector::IsCorruptionDetectionEnabled() const
+{
+    const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
+        (VMA_DEBUG_MARGIN > 0) &&
+        (m_Algorithm == 0 || m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) &&
+        (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
+}
+
+VkResult VmaBlockVector::Allocate(
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaSuballocationType suballocType,
+    size_t allocationCount,
+    VmaAllocation* pAllocations)
+{
+    size_t allocIndex;
+    VkResult res = VK_SUCCESS;
+
+    alignment = VMA_MAX(alignment, m_MinAllocationAlignment);
+
+    if (IsCorruptionDetectionEnabled())
+    {
+        size = VmaAlignUp<VkDeviceSize>(size, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
+        alignment = VmaAlignUp<VkDeviceSize>(alignment, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
+    }
+
+    {
+        VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
+        for (allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+        {
+            res = AllocatePage(
+                size,
+                alignment,
+                createInfo,
+                suballocType,
+                pAllocations + allocIndex);
+            if (res != VK_SUCCESS)
+            {
+                break;
+            }
+        }
+    }
+
+    if (res != VK_SUCCESS)
+    {
+        // Free all already created allocations.
+        while (allocIndex--)
+            Free(pAllocations[allocIndex]);
+        memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
+    }
+
+    return res;
+}
+
+VkResult VmaBlockVector::AllocatePage(
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaSuballocationType suballocType,
+    VmaAllocation* pAllocation)
+{
+    const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
+
+    VkDeviceSize freeMemory;
+    {
+        const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
+        VmaBudget heapBudget = {};
+        m_hAllocator->GetHeapBudgets(&heapBudget, heapIndex, 1);
+        freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;
+    }
+
+    const bool canFallbackToDedicated = !HasExplicitBlockSize() &&
+        (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0;
+    const bool canCreateNewBlock =
+        ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
+        (m_Blocks.size() < m_MaxBlockCount) &&
+        (freeMemory >= size || !canFallbackToDedicated);
+    uint32_t strategy = createInfo.flags & VMA_ALLOCATION_CREATE_STRATEGY_MASK;
+
+    // Upper address can only be used with linear allocator and within single memory block.
+    if (isUpperAddress &&
+        (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT || m_MaxBlockCount > 1))
+    {
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    // Early reject: requested allocation size is larger that maximum block size for this block vector.
+    if (size + VMA_DEBUG_MARGIN > m_PreferredBlockSize)
+    {
+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+    }
+
+    // 1. Search existing allocations. Try to allocate.
+    if (m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
+    {
+        // Use only last block.
+        if (!m_Blocks.empty())
+        {
+            VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
+            VMA_ASSERT(pCurrBlock);
+            VkResult res = AllocateFromBlock(
+                pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
+            if (res == VK_SUCCESS)
+            {
+                VMA_DEBUG_LOG("    Returned from last block #%u", pCurrBlock->GetId());
+                IncrementallySortBlocks();
+                return VK_SUCCESS;
+            }
+        }
+    }
+    else
+    {
+        if (strategy != VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT) // MIN_MEMORY or default
+        {
+            const bool isHostVisible =
+                (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;
+            if(isHostVisible)
+            {
+                const bool isMappingAllowed = (createInfo.flags &
+                    (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0;
+                /*
+                For non-mappable allocations, check blocks that are not mapped first.
+                For mappable allocations, check blocks that are already mapped first.
+                This way, having many blocks, we will separate mappable and non-mappable allocations,
+                hopefully limiting the number of blocks that are mapped, which will help tools like RenderDoc.
+                */
+                for(size_t mappingI = 0; mappingI < 2; ++mappingI)
+                {
+                    // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
+                    for (size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+                    {
+                        VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
+                        VMA_ASSERT(pCurrBlock);
+                        const bool isBlockMapped = pCurrBlock->GetMappedData() != VMA_NULL;
+                        if((mappingI == 0) == (isMappingAllowed == isBlockMapped))
+                        {
+                            VkResult res = AllocateFromBlock(
+                                pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
+                            if (res == VK_SUCCESS)
+                            {
+                                VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
+                                IncrementallySortBlocks();
+                                return VK_SUCCESS;
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
+                for (size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+                {
+                    VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
+                    VMA_ASSERT(pCurrBlock);
+                    VkResult res = AllocateFromBlock(
+                        pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
+                    if (res == VK_SUCCESS)
+                    {
+                        VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
+                        IncrementallySortBlocks();
+                        return VK_SUCCESS;
+                    }
+                }
+            }
+        }
+        else // VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT
+        {
+            // Backward order in m_Blocks - prefer blocks with largest amount of free space.
+            for (size_t blockIndex = m_Blocks.size(); blockIndex--; )
+            {
+                VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
+                VMA_ASSERT(pCurrBlock);
+                VkResult res = AllocateFromBlock(pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
+                if (res == VK_SUCCESS)
+                {
+                    VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());
+                    IncrementallySortBlocks();
+                    return VK_SUCCESS;
+                }
+            }
+        }
+    }
+
+    // 2. Try to create new block.
+    if (canCreateNewBlock)
+    {
+        // Calculate optimal size for new block.
+        VkDeviceSize newBlockSize = m_PreferredBlockSize;
+        uint32_t newBlockSizeShift = 0;
+        const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
+
+        if (!m_ExplicitBlockSize)
+        {
+            // Allocate 1/8, 1/4, 1/2 as first blocks.
+            const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
+            for (uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
+            {
+                const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
+                if (smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
+                {
+                    newBlockSize = smallerNewBlockSize;
+                    ++newBlockSizeShift;
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        size_t newBlockIndex = 0;
+        VkResult res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
+            CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
+        if (!m_ExplicitBlockSize)
+        {
+            while (res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
+            {
+                const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
+                if (smallerNewBlockSize >= size)
+                {
+                    newBlockSize = smallerNewBlockSize;
+                    ++newBlockSizeShift;
+                    res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
+                        CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        if (res == VK_SUCCESS)
+        {
+            VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
+            VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
+
+            res = AllocateFromBlock(
+                pBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
+            if (res == VK_SUCCESS)
+            {
+                VMA_DEBUG_LOG("    Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
+                IncrementallySortBlocks();
+                return VK_SUCCESS;
+            }
+            else
+            {
+                // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+        }
+    }
+
+    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+}
+
+void VmaBlockVector::Free(const VmaAllocation hAllocation)
+{
+    VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
+
+    bool budgetExceeded = false;
+    {
+        const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
+        VmaBudget heapBudget = {};
+        m_hAllocator->GetHeapBudgets(&heapBudget, heapIndex, 1);
+        budgetExceeded = heapBudget.usage >= heapBudget.budget;
+    }
+
+    // Scope for lock.
+    {
+        VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+        VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
+
+        if (IsCorruptionDetectionEnabled())
+        {
+            VkResult res = pBlock->ValidateMagicValueAfterAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
+            VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
+        }
+
+        if (hAllocation->IsPersistentMap())
+        {
+            pBlock->Unmap(m_hAllocator, 1);
+        }
+
+        const bool hadEmptyBlockBeforeFree = HasEmptyBlock();
+        pBlock->m_pMetadata->Free(hAllocation->GetAllocHandle());
+        pBlock->PostFree(m_hAllocator);
+        VMA_HEAVY_ASSERT(pBlock->Validate());
+
+        VMA_DEBUG_LOG("  Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
+
+        const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
+        // pBlock became empty after this deallocation.
+        if (pBlock->m_pMetadata->IsEmpty())
+        {
+            // Already had empty block. We don't want to have two, so delete this one.
+            if ((hadEmptyBlockBeforeFree || budgetExceeded) && canDeleteBlock)
+            {
+                pBlockToDelete = pBlock;
+                Remove(pBlock);
+            }
+            // else: We now have one empty block - leave it. A hysteresis to avoid allocating whole block back and forth.
+        }
+        // pBlock didn't become empty, but we have another empty block - find and free that one.
+        // (This is optional, heuristics.)
+        else if (hadEmptyBlockBeforeFree && canDeleteBlock)
+        {
+            VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
+            if (pLastBlock->m_pMetadata->IsEmpty())
+            {
+                pBlockToDelete = pLastBlock;
+                m_Blocks.pop_back();
+            }
+        }
+
+        IncrementallySortBlocks();
+    }
+
+    // Destruction of a free block. Deferred until this point, outside of mutex
+    // lock, for performance reason.
+    if (pBlockToDelete != VMA_NULL)
+    {
+        VMA_DEBUG_LOG("    Deleted empty block #%u", pBlockToDelete->GetId());
+        pBlockToDelete->Destroy(m_hAllocator);
+        vma_delete(m_hAllocator, pBlockToDelete);
+    }
+
+    m_hAllocator->m_Budget.RemoveAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), hAllocation->GetSize());
+    m_hAllocator->m_AllocationObjectAllocator.Free(hAllocation);
+}
+
+VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
+{
+    VkDeviceSize result = 0;
+    for (size_t i = m_Blocks.size(); i--; )
+    {
+        result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
+        if (result >= m_PreferredBlockSize)
+        {
+            break;
+        }
+    }
+    return result;
+}
+
+void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
+{
+    for (uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+    {
+        if (m_Blocks[blockIndex] == pBlock)
+        {
+            VmaVectorRemove(m_Blocks, blockIndex);
+            return;
+        }
+    }
+    VMA_ASSERT(0);
+}
+
+void VmaBlockVector::IncrementallySortBlocks()
+{
+    if (!m_IncrementalSort)
+        return;
+    if (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
+    {
+        // Bubble sort only until first swap.
+        for (size_t i = 1; i < m_Blocks.size(); ++i)
+        {
+            if (m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
+            {
+                VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
+                return;
+            }
+        }
+    }
+}
+
+void VmaBlockVector::SortByFreeSize()
+{
+    VMA_SORT(m_Blocks.begin(), m_Blocks.end(),
+        [](VmaDeviceMemoryBlock* b1, VmaDeviceMemoryBlock* b2) -> bool
+        {
+            return b1->m_pMetadata->GetSumFreeSize() < b2->m_pMetadata->GetSumFreeSize();
+        });
+}
+
+VkResult VmaBlockVector::AllocateFromBlock(
+    VmaDeviceMemoryBlock* pBlock,
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    VmaAllocationCreateFlags allocFlags,
+    void* pUserData,
+    VmaSuballocationType suballocType,
+    uint32_t strategy,
+    VmaAllocation* pAllocation)
+{
+    const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
+
+    VmaAllocationRequest currRequest = {};
+    if (pBlock->m_pMetadata->CreateAllocationRequest(
+        size,
+        alignment,
+        isUpperAddress,
+        suballocType,
+        strategy,
+        &currRequest))
+    {
+        return CommitAllocationRequest(currRequest, pBlock, alignment, allocFlags, pUserData, suballocType, pAllocation);
+    }
+    return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+}
+
+VkResult VmaBlockVector::CommitAllocationRequest(
+    VmaAllocationRequest& allocRequest,
+    VmaDeviceMemoryBlock* pBlock,
+    VkDeviceSize alignment,
+    VmaAllocationCreateFlags allocFlags,
+    void* pUserData,
+    VmaSuballocationType suballocType,
+    VmaAllocation* pAllocation)
+{
+    const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
+    const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
+    const bool isMappingAllowed = (allocFlags &
+        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0;
+
+    pBlock->PostAlloc();
+    // Allocate from pCurrBlock.
+    if (mapped)
+    {
+        VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
+        if (res != VK_SUCCESS)
+        {
+            return res;
+        }
+    }
+
+    *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate(isMappingAllowed);
+    pBlock->m_pMetadata->Alloc(allocRequest, suballocType, *pAllocation);
+    (*pAllocation)->InitBlockAllocation(
+        pBlock,
+        allocRequest.allocHandle,
+        alignment,
+        allocRequest.size, // Not size, as actual allocation size may be larger than requested!
+        m_MemoryTypeIndex,
+        suballocType,
+        mapped);
+    VMA_HEAVY_ASSERT(pBlock->Validate());
+    if (isUserDataString)
+        (*pAllocation)->SetName(m_hAllocator, (const char*)pUserData);
+    else
+        (*pAllocation)->SetUserData(m_hAllocator, pUserData);
+    m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), allocRequest.size);
+    if (VMA_DEBUG_INITIALIZE_ALLOCATIONS)
+    {
+        m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
+    }
+    if (IsCorruptionDetectionEnabled())
+    {
+        VkResult res = pBlock->WriteMagicValueAfterAllocation(m_hAllocator, (*pAllocation)->GetOffset(), allocRequest.size);
+        VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
+    }
+    return VK_SUCCESS;
+}
+
+VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
+{
+    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+    allocInfo.pNext = m_pMemoryAllocateNext;
+    allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
+    allocInfo.allocationSize = blockSize;
+
+#if VMA_BUFFER_DEVICE_ADDRESS
+    // Every standalone block can potentially contain a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT - always enable the feature.
+    VkMemoryAllocateFlagsInfoKHR allocFlagsInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR };
+    if (m_hAllocator->m_UseKhrBufferDeviceAddress)
+    {
+        allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
+        VmaPnextChainPushFront(&allocInfo, &allocFlagsInfo);
+    }
+#endif // VMA_BUFFER_DEVICE_ADDRESS
+
+#if VMA_MEMORY_PRIORITY
+    VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
+    if (m_hAllocator->m_UseExtMemoryPriority)
+    {
+        VMA_ASSERT(m_Priority >= 0.f && m_Priority <= 1.f);
+        priorityInfo.priority = m_Priority;
+        VmaPnextChainPushFront(&allocInfo, &priorityInfo);
+    }
+#endif // VMA_MEMORY_PRIORITY
+
+#if VMA_EXTERNAL_MEMORY
+    // Attach VkExportMemoryAllocateInfoKHR if necessary.
+    VkExportMemoryAllocateInfoKHR exportMemoryAllocInfo = { VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR };
+    exportMemoryAllocInfo.handleTypes = m_hAllocator->GetExternalMemoryHandleTypeFlags(m_MemoryTypeIndex);
+    if (exportMemoryAllocInfo.handleTypes != 0)
+    {
+        VmaPnextChainPushFront(&allocInfo, &exportMemoryAllocInfo);
+    }
+#endif // VMA_EXTERNAL_MEMORY
+
+    VkDeviceMemory mem = VK_NULL_HANDLE;
+    VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
+    if (res < 0)
+    {
+        return res;
+    }
+
+    // New VkDeviceMemory successfully created.
+
+    // Create new Allocation for it.
+    VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
+    pBlock->Init(
+        m_hAllocator,
+        m_hParentPool,
+        m_MemoryTypeIndex,
+        mem,
+        allocInfo.allocationSize,
+        m_NextBlockId++,
+        m_Algorithm,
+        m_BufferImageGranularity);
+
+    m_Blocks.push_back(pBlock);
+    if (pNewBlockIndex != VMA_NULL)
+    {
+        *pNewBlockIndex = m_Blocks.size() - 1;
+    }
+
+    return VK_SUCCESS;
+}
+
+bool VmaBlockVector::HasEmptyBlock()
+{
+    for (size_t index = 0, count = m_Blocks.size(); index < count; ++index)
+    {
+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[index];
+        if (pBlock->m_pMetadata->IsEmpty())
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
+{
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+
+
+    json.BeginObject();
+    for (size_t i = 0; i < m_Blocks.size(); ++i)
+    {
+        json.BeginString();
+        json.ContinueString(m_Blocks[i]->GetId());
+        json.EndString();
+
+        json.BeginObject();
+        json.WriteString("MapRefCount");
+        json.WriteNumber(m_Blocks[i]->GetMapRefCount());
+
+        m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
+        json.EndObject();
+    }
+    json.EndObject();
+}
+#endif // VMA_STATS_STRING_ENABLED
+
+VkResult VmaBlockVector::CheckCorruption()
+{
+    if (!IsCorruptionDetectionEnabled())
+    {
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
+    for (uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
+    {
+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
+        VMA_ASSERT(pBlock);
+        VkResult res = pBlock->CheckCorruption(m_hAllocator);
+        if (res != VK_SUCCESS)
+        {
+            return res;
+        }
+    }
+    return VK_SUCCESS;
+}
+
+#endif // _VMA_BLOCK_VECTOR_FUNCTIONS
+
+#ifndef _VMA_DEFRAGMENTATION_CONTEXT_FUNCTIONS
+VmaDefragmentationContext_T::VmaDefragmentationContext_T(
+    VmaAllocator hAllocator,
+    const VmaDefragmentationInfo& info)
+    : m_MaxPassBytes(info.maxBytesPerPass == 0 ? VK_WHOLE_SIZE : info.maxBytesPerPass),
+    m_MaxPassAllocations(info.maxAllocationsPerPass == 0 ? UINT32_MAX : info.maxAllocationsPerPass),
+    m_MoveAllocator(hAllocator->GetAllocationCallbacks()),
+    m_Moves(m_MoveAllocator)
+{
+    m_Algorithm = info.flags & VMA_DEFRAGMENTATION_FLAG_ALGORITHM_MASK;
+
+    if (info.pool != VMA_NULL)
+    {
+        m_BlockVectorCount = 1;
+        m_PoolBlockVector = &info.pool->m_BlockVector;
+        m_pBlockVectors = &m_PoolBlockVector;
+        m_PoolBlockVector->SetIncrementalSort(false);
+        m_PoolBlockVector->SortByFreeSize();
+    }
+    else
+    {
+        m_BlockVectorCount = hAllocator->GetMemoryTypeCount();
+        m_PoolBlockVector = VMA_NULL;
+        m_pBlockVectors = hAllocator->m_pBlockVectors;
+        for (uint32_t i = 0; i < m_BlockVectorCount; ++i)
+        {
+            VmaBlockVector* vector = m_pBlockVectors[i];
+            if (vector != VMA_NULL)
+            {
+                vector->SetIncrementalSort(false);
+                vector->SortByFreeSize();
+            }
+        }
+    }
+    
+    switch (m_Algorithm)
+    {
+    case 0: // Default algorithm
+        m_Algorithm = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT;
+    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT:
+    {
+        m_AlgorithmState = vma_new_array(hAllocator, StateBalanced, m_BlockVectorCount);
+        break;
+    }
+    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
+    {
+        if (hAllocator->GetBufferImageGranularity() > 1)
+        {
+            m_AlgorithmState = vma_new_array(hAllocator, StateExtensive, m_BlockVectorCount);
+        }
+        break;
+    }
+    }
+}
+
+VmaDefragmentationContext_T::~VmaDefragmentationContext_T()
+{
+    if (m_PoolBlockVector != VMA_NULL)
+    {
+        m_PoolBlockVector->SetIncrementalSort(true);
+    }
+    else
+    {
+        for (uint32_t i = 0; i < m_BlockVectorCount; ++i)
+        {
+            VmaBlockVector* vector = m_pBlockVectors[i];
+            if (vector != VMA_NULL)
+                vector->SetIncrementalSort(true);
+        }
+    }
+
+    if (m_AlgorithmState)
+    {
+        switch (m_Algorithm)
+        {
+        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT:
+            vma_delete_array(m_MoveAllocator.m_pCallbacks, reinterpret_cast<StateBalanced*>(m_AlgorithmState), m_BlockVectorCount);
+            break;
+        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
+            vma_delete_array(m_MoveAllocator.m_pCallbacks, reinterpret_cast<StateExtensive*>(m_AlgorithmState), m_BlockVectorCount);
+            break;
+        default:
+            VMA_ASSERT(0);
+        }
+    }
+}
+
+VkResult VmaDefragmentationContext_T::DefragmentPassBegin(VmaDefragmentationPassMoveInfo& moveInfo)
+{
+    if (m_PoolBlockVector != VMA_NULL)
+    {
+        VmaMutexLockWrite lock(m_PoolBlockVector->GetMutex(), m_PoolBlockVector->GetAllocator()->m_UseMutex);
+
+        if (m_PoolBlockVector->GetBlockCount() > 1)
+            ComputeDefragmentation(*m_PoolBlockVector, 0);
+        else if (m_PoolBlockVector->GetBlockCount() == 1)
+            ReallocWithinBlock(*m_PoolBlockVector, m_PoolBlockVector->GetBlock(0));
+    }
+    else
+    {
+        for (uint32_t i = 0; i < m_BlockVectorCount; ++i)
+        {
+            if (m_pBlockVectors[i] != VMA_NULL)
+            {
+                VmaMutexLockWrite lock(m_pBlockVectors[i]->GetMutex(), m_pBlockVectors[i]->GetAllocator()->m_UseMutex);
+
+                if (m_pBlockVectors[i]->GetBlockCount() > 1)
+                {
+                    if (ComputeDefragmentation(*m_pBlockVectors[i], i))
+                        break;
+                }
+                else if (m_pBlockVectors[i]->GetBlockCount() == 1)
+                {
+                    if (ReallocWithinBlock(*m_pBlockVectors[i], m_pBlockVectors[i]->GetBlock(0)))
+                        break;
+                }
+            }
+        }
+    }
+
+    moveInfo.moveCount = static_cast<uint32_t>(m_Moves.size());
+    if (moveInfo.moveCount > 0)
+    {
+        moveInfo.pMoves = m_Moves.data();
+        return VK_INCOMPLETE;
+    }
+
+    moveInfo.pMoves = VMA_NULL;
+    return VK_SUCCESS;
+}
+
+VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMoveInfo& moveInfo)
+{
+    VMA_ASSERT(moveInfo.moveCount > 0 ? moveInfo.pMoves != VMA_NULL : true);
+
+    VkResult result = VK_SUCCESS;
+    VmaStlAllocator<FragmentedBlock> blockAllocator(m_MoveAllocator.m_pCallbacks);
+    VmaVector<FragmentedBlock, VmaStlAllocator<FragmentedBlock>> immovableBlocks(blockAllocator);
+    VmaVector<FragmentedBlock, VmaStlAllocator<FragmentedBlock>> mappedBlocks(blockAllocator);
+
+    VmaAllocator allocator = VMA_NULL;
+    for (uint32_t i = 0; i < moveInfo.moveCount; ++i)
+    {
+        VmaDefragmentationMove& move = moveInfo.pMoves[i];
+        size_t prevCount = 0, currentCount = 0;
+        VkDeviceSize freedBlockSize = 0;
+
+        uint32_t vectorIndex;
+        VmaBlockVector* vector;
+        if (m_PoolBlockVector != VMA_NULL)
+        {
+            vectorIndex = 0;
+            vector = m_PoolBlockVector;
+        }
+        else
+        {
+            vectorIndex = move.srcAllocation->GetMemoryTypeIndex();
+            vector = m_pBlockVectors[vectorIndex];
+            VMA_ASSERT(vector != VMA_NULL);
+        }
+        
+        switch (move.operation)
+        {
+        case VMA_DEFRAGMENTATION_MOVE_OPERATION_COPY:
+        {
+            uint8_t mapCount = move.srcAllocation->SwapBlockAllocation(vector->m_hAllocator, move.dstTmpAllocation);
+            if (mapCount > 0)
+            {
+                allocator = vector->m_hAllocator;
+                VmaDeviceMemoryBlock* newMapBlock = move.srcAllocation->GetBlock();
+                bool notPresent = true;
+                for (FragmentedBlock& block : mappedBlocks)
+                {
+                    if (block.block == newMapBlock)
+                    {
+                        notPresent = false;
+                        block.data += mapCount;
+                        break;
+                    }
+                }
+                if (notPresent)
+                    mappedBlocks.push_back({ mapCount, newMapBlock });
+            }
+
+            // Scope for locks, Free have it's own lock
+            {
+                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+                prevCount = vector->GetBlockCount();
+                freedBlockSize = move.dstTmpAllocation->GetBlock()->m_pMetadata->GetSize();
+            }
+            vector->Free(move.dstTmpAllocation);
+            {
+                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+                currentCount = vector->GetBlockCount();
+            }
+
+            result = VK_INCOMPLETE;
+            break;
+        }
+        case VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE:
+        {
+            m_PassStats.bytesMoved -= move.srcAllocation->GetSize();
+            --m_PassStats.allocationsMoved;
+            vector->Free(move.dstTmpAllocation);
+
+            VmaDeviceMemoryBlock* newBlock = move.srcAllocation->GetBlock();
+            bool notPresent = true;
+            for (const FragmentedBlock& block : immovableBlocks)
+            {
+                if (block.block == newBlock)
+                {
+                    notPresent = false;
+                    break;
+                }
+            }
+            if (notPresent)
+                immovableBlocks.push_back({ vectorIndex, newBlock });
+            break;
+        }
+        case VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY:
+        {
+            m_PassStats.bytesMoved -= move.srcAllocation->GetSize();
+            --m_PassStats.allocationsMoved;
+            // Scope for locks, Free have it's own lock
+            {
+                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+                prevCount = vector->GetBlockCount();
+                freedBlockSize = move.srcAllocation->GetBlock()->m_pMetadata->GetSize();
+            }
+            vector->Free(move.srcAllocation);
+            {
+                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+                currentCount = vector->GetBlockCount();
+            }
+            freedBlockSize *= prevCount - currentCount;
+
+            VkDeviceSize dstBlockSize;
+            {
+                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+                dstBlockSize = move.dstTmpAllocation->GetBlock()->m_pMetadata->GetSize();
+            }
+            vector->Free(move.dstTmpAllocation);
+            {
+                VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+                freedBlockSize += dstBlockSize * (currentCount - vector->GetBlockCount());
+                currentCount = vector->GetBlockCount();
+            }
+
+            result = VK_INCOMPLETE;
+            break;
+        }
+        default:
+            VMA_ASSERT(0);
+        }
+
+        if (prevCount > currentCount)
+        {
+            size_t freedBlocks = prevCount - currentCount;
+            m_PassStats.deviceMemoryBlocksFreed += static_cast<uint32_t>(freedBlocks);
+            m_PassStats.bytesFreed += freedBlockSize;
+        }
+
+        switch (m_Algorithm)
+        {
+        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
+        {
+            if (m_AlgorithmState != VMA_NULL)
+            {
+                // Avoid unnecessary tries to allocate when new free block is avaiable
+                StateExtensive& state = reinterpret_cast<StateExtensive*>(m_AlgorithmState)[vectorIndex];
+                if (state.firstFreeBlock != SIZE_MAX)
+                {
+                    const size_t diff = prevCount - currentCount;
+                    if (state.firstFreeBlock >= diff)
+                    {
+                        state.firstFreeBlock -= diff;
+                        if (state.firstFreeBlock != 0)
+                            state.firstFreeBlock -= vector->GetBlock(state.firstFreeBlock - 1)->m_pMetadata->IsEmpty();
+                    }
+                    else
+                        state.firstFreeBlock = 0;
+                }
+            }
+        }
+        }
+    }
+    moveInfo.moveCount = 0;
+    moveInfo.pMoves = VMA_NULL;
+    m_Moves.clear();
+
+    // Update stats
+    m_GlobalStats.allocationsMoved += m_PassStats.allocationsMoved;
+    m_GlobalStats.bytesFreed += m_PassStats.bytesFreed;
+    m_GlobalStats.bytesMoved += m_PassStats.bytesMoved;
+    m_GlobalStats.deviceMemoryBlocksFreed += m_PassStats.deviceMemoryBlocksFreed;
+    m_PassStats = { 0 };
+
+    // Move blocks with immovable allocations according to algorithm
+    if (immovableBlocks.size() > 0)
+    {
+        switch (m_Algorithm)
+        {
+        case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
+        {
+            if (m_AlgorithmState != VMA_NULL)
+            {
+                bool swapped = false;
+                // Move to the start of free blocks range
+                for (const FragmentedBlock& block : immovableBlocks)
+                {
+                    StateExtensive& state = reinterpret_cast<StateExtensive*>(m_AlgorithmState)[block.data];
+                    if (state.operation != StateExtensive::Operation::Cleanup)
+                    {
+                        VmaBlockVector* vector = m_pBlockVectors[block.data];
+                        VmaMutexLockWrite lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+
+                        for (size_t i = 0, count = vector->GetBlockCount() - m_ImmovableBlockCount; i < count; ++i)
+                        {
+                            if (vector->GetBlock(i) == block.block)
+                            {
+                                VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[vector->GetBlockCount() - ++m_ImmovableBlockCount]);
+                                if (state.firstFreeBlock != SIZE_MAX)
+                                {
+                                    if (i + 1 < state.firstFreeBlock)
+                                    {
+                                        if (state.firstFreeBlock > 1)
+                                            VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[--state.firstFreeBlock]);
+                                        else
+                                            --state.firstFreeBlock;
+                                    }
+                                }
+                                swapped = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (swapped)
+                    result = VK_INCOMPLETE;
+                break;
+            }
+        }
+        default:
+        {
+            // Move to the begining
+            for (const FragmentedBlock& block : immovableBlocks)
+            {
+                VmaBlockVector* vector = m_pBlockVectors[block.data];
+                VmaMutexLockWrite lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
+
+                for (size_t i = m_ImmovableBlockCount; i < vector->GetBlockCount(); ++i)
+                {
+                    if (vector->GetBlock(i) == block.block)
+                    {
+                        VMA_SWAP(vector->m_Blocks[i], vector->m_Blocks[m_ImmovableBlockCount++]);
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+        }
+    }
+
+    // Bulk-map destination blocks
+    for (const FragmentedBlock& block : mappedBlocks)
+    {
+        VkResult res = block.block->Map(allocator, block.data, VMA_NULL);
+        VMA_ASSERT(res == VK_SUCCESS);
+    }
+    return result;
+}
+
+bool VmaDefragmentationContext_T::ComputeDefragmentation(VmaBlockVector& vector, size_t index)
+{
+    switch (m_Algorithm)
+    {
+    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT:
+        return ComputeDefragmentation_Fast(vector);
+    default:
+        VMA_ASSERT(0);
+    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_BALANCED_BIT:
+        return ComputeDefragmentation_Balanced(vector, index, true);
+    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FULL_BIT:
+        return ComputeDefragmentation_Full(vector);
+    case VMA_DEFRAGMENTATION_FLAG_ALGORITHM_EXTENSIVE_BIT:
+        return ComputeDefragmentation_Extensive(vector, index);
+    }
+}
+
+VmaDefragmentationContext_T::MoveAllocationData VmaDefragmentationContext_T::GetMoveData(
+    VmaAllocHandle handle, VmaBlockMetadata* metadata)
+{
+    MoveAllocationData moveData;
+    moveData.move.srcAllocation = (VmaAllocation)metadata->GetAllocationUserData(handle);
+    moveData.size = moveData.move.srcAllocation->GetSize();
+    moveData.alignment = moveData.move.srcAllocation->GetAlignment();
+    moveData.type = moveData.move.srcAllocation->GetSuballocationType();
+    moveData.flags = 0;
+
+    if (moveData.move.srcAllocation->IsPersistentMap())
+        moveData.flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
+    if (moveData.move.srcAllocation->IsMappingAllowed())
+        moveData.flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
+
+    return moveData;
+}
+
+VmaDefragmentationContext_T::CounterStatus VmaDefragmentationContext_T::CheckCounters(VkDeviceSize bytes)
+{
+    // Ignore allocation if will exceed max size for copy
+    if (m_PassStats.bytesMoved + bytes > m_MaxPassBytes)
+    {
+        if (++m_IgnoredAllocs < MAX_ALLOCS_TO_IGNORE)
+            return CounterStatus::Ignore;
+        else
+            return CounterStatus::End;
+    }
+    return CounterStatus::Pass;
+}
+
+bool VmaDefragmentationContext_T::IncrementCounters(VkDeviceSize bytes)
+{
+    m_PassStats.bytesMoved += bytes;
+    // Early return when max found
+    if (++m_PassStats.allocationsMoved >= m_MaxPassAllocations || m_PassStats.bytesMoved >= m_MaxPassBytes)
+    {
+        VMA_ASSERT(m_PassStats.allocationsMoved == m_MaxPassAllocations ||
+            m_PassStats.bytesMoved == m_MaxPassBytes && "Exceeded maximal pass threshold!");
+        return true;
+    }
+    return false;
+}
+
+bool VmaDefragmentationContext_T::ReallocWithinBlock(VmaBlockVector& vector, VmaDeviceMemoryBlock* block)
+{
+    VmaBlockMetadata* metadata = block->m_pMetadata;
+
+    for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
+        handle != VK_NULL_HANDLE;
+        handle = metadata->GetNextAllocation(handle))
+    {
+        MoveAllocationData moveData = GetMoveData(handle, metadata);
+        // Ignore newly created allocations by defragmentation algorithm
+        if (moveData.move.srcAllocation->GetUserData() == this)
+            continue;
+        switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
+        {
+        case CounterStatus::Ignore:
+            continue;
+        case CounterStatus::End:
+            return true;
+        default:
+            VMA_ASSERT(0);
+        case CounterStatus::Pass:
+            break;
+        }
+        
+        VkDeviceSize offset = moveData.move.srcAllocation->GetOffset();
+        if (offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
+        {
+            VmaAllocationRequest request = {};
+            if (metadata->CreateAllocationRequest(
+                moveData.size,
+                moveData.alignment,
+                false,
+                moveData.type,
+                VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
+                &request))
+            {
+                if (metadata->GetAllocationOffset(request.allocHandle) < offset)
+                {
+                    if (vector.CommitAllocationRequest(
+                        request,
+                        block,
+                        moveData.alignment,
+                        moveData.flags,
+                        this,
+                        moveData.type,
+                        &moveData.move.dstTmpAllocation) == VK_SUCCESS)
+                    {
+                        m_Moves.push_back(moveData.move);
+                        if (IncrementCounters(moveData.size))
+                            return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool VmaDefragmentationContext_T::AllocInOtherBlock(size_t start, size_t end, MoveAllocationData& data, VmaBlockVector& vector)
+{
+    for (; start < end; ++start)
+    {
+        VmaDeviceMemoryBlock* dstBlock = vector.GetBlock(start);
+        if (dstBlock->m_pMetadata->GetSumFreeSize() >= data.size)
+        {
+            if (vector.AllocateFromBlock(dstBlock,
+                data.size,
+                data.alignment,
+                data.flags,
+                this,
+                data.type,
+                0,
+                &data.move.dstTmpAllocation) == VK_SUCCESS)
+            {
+                m_Moves.push_back(data.move);
+                if (IncrementCounters(data.size))
+                    return true;
+                break;
+            }
+        }
+    }
+    return false;
+}
+
+bool VmaDefragmentationContext_T::ComputeDefragmentation_Fast(VmaBlockVector& vector)
+{
+    // Move only between blocks
+
+    // Go through allocations in last blocks and try to fit them inside first ones
+    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
+    {
+        VmaBlockMetadata* metadata = vector.GetBlock(i)->m_pMetadata;
+
+        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
+            handle != VK_NULL_HANDLE;
+            handle = metadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, metadata);
+            // Ignore newly created allocations by defragmentation algorithm
+            if (moveData.move.srcAllocation->GetUserData() == this)
+                continue;
+            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                VMA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Check all previous blocks for free space
+            if (AllocInOtherBlock(0, i, moveData, vector))
+                return true;
+        }
+    }
+    return false;
+}
+
+bool VmaDefragmentationContext_T::ComputeDefragmentation_Balanced(VmaBlockVector& vector, size_t index, bool update)
+{
+    // Go over every allocation and try to fit it in previous blocks at lowest offsets,
+    // if not possible: realloc within single block to minimize offset (exclude offset == 0),
+    // but only if there are noticable gaps between them (some heuristic, ex. average size of allocation in block)
+    VMA_ASSERT(m_AlgorithmState != VMA_NULL);
+
+    StateBalanced& vectorState = reinterpret_cast<StateBalanced*>(m_AlgorithmState)[index];
+    if (update && vectorState.avgAllocSize == UINT64_MAX)
+        UpdateVectorStatistics(vector, vectorState);
+
+    const size_t startMoveCount = m_Moves.size();
+    VkDeviceSize minimalFreeRegion = vectorState.avgFreeSize / 2;
+    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
+    {
+        VmaDeviceMemoryBlock* block = vector.GetBlock(i);
+        VmaBlockMetadata* metadata = block->m_pMetadata;
+        VkDeviceSize prevFreeRegionSize = 0;
+
+        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
+            handle != VK_NULL_HANDLE;
+            handle = metadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, metadata);
+            // Ignore newly created allocations by defragmentation algorithm
+            if (moveData.move.srcAllocation->GetUserData() == this)
+                continue;
+            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                VMA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Check all previous blocks for free space
+            const size_t prevMoveCount = m_Moves.size();
+            if (AllocInOtherBlock(0, i, moveData, vector))
+                return true;
+
+            VkDeviceSize nextFreeRegionSize = metadata->GetNextFreeRegionSize(handle);
+            // If no room found then realloc within block for lower offset
+            VkDeviceSize offset = moveData.move.srcAllocation->GetOffset();
+            if (prevMoveCount == m_Moves.size() && offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
+            {
+                // Check if realloc will make sense
+                if (prevFreeRegionSize >= minimalFreeRegion ||
+                    nextFreeRegionSize >= minimalFreeRegion ||
+                    moveData.size <= vectorState.avgFreeSize ||
+                    moveData.size <= vectorState.avgAllocSize)
+                {
+                    VmaAllocationRequest request = {};
+                    if (metadata->CreateAllocationRequest(
+                        moveData.size,
+                        moveData.alignment,
+                        false,
+                        moveData.type,
+                        VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
+                        &request))
+                    {
+                        if (metadata->GetAllocationOffset(request.allocHandle) < offset)
+                        {
+                            if (vector.CommitAllocationRequest(
+                                request,
+                                block,
+                                moveData.alignment,
+                                moveData.flags,
+                                this,
+                                moveData.type,
+                                &moveData.move.dstTmpAllocation) == VK_SUCCESS)
+                            {
+                                m_Moves.push_back(moveData.move);
+                                if (IncrementCounters(moveData.size))
+                                    return true;
+                            }
+                        }
+                    }
+                }
+            }
+            prevFreeRegionSize = nextFreeRegionSize;
+        }
+    }
+    
+    // No moves perfomed, update statistics to current vector state
+    if (startMoveCount == m_Moves.size() && !update)
+    {
+        vectorState.avgAllocSize = UINT64_MAX;
+        return ComputeDefragmentation_Balanced(vector, index, false);
+    }
+    return false;
+}
+
+bool VmaDefragmentationContext_T::ComputeDefragmentation_Full(VmaBlockVector& vector)
+{
+    // Go over every allocation and try to fit it in previous blocks at lowest offsets,
+    // if not possible: realloc within single block to minimize offset (exclude offset == 0)
+
+    for (size_t i = vector.GetBlockCount() - 1; i > m_ImmovableBlockCount; --i)
+    {
+        VmaDeviceMemoryBlock* block = vector.GetBlock(i);
+        VmaBlockMetadata* metadata = block->m_pMetadata;
+
+        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
+            handle != VK_NULL_HANDLE;
+            handle = metadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, metadata);
+            // Ignore newly created allocations by defragmentation algorithm
+            if (moveData.move.srcAllocation->GetUserData() == this)
+                continue;
+            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                VMA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Check all previous blocks for free space
+            const size_t prevMoveCount = m_Moves.size();
+            if (AllocInOtherBlock(0, i, moveData, vector))
+                return true;
+
+            // If no room found then realloc within block for lower offset
+            VkDeviceSize offset = moveData.move.srcAllocation->GetOffset();
+            if (prevMoveCount == m_Moves.size() && offset != 0 && metadata->GetSumFreeSize() >= moveData.size)
+            {
+                VmaAllocationRequest request = {};
+                if (metadata->CreateAllocationRequest(
+                    moveData.size,
+                    moveData.alignment,
+                    false,
+                    moveData.type,
+                    VMA_ALLOCATION_CREATE_STRATEGY_MIN_OFFSET_BIT,
+                    &request))
+                {
+                    if (metadata->GetAllocationOffset(request.allocHandle) < offset)
+                    {
+                        if (vector.CommitAllocationRequest(
+                            request,
+                            block,
+                            moveData.alignment,
+                            moveData.flags,
+                            this,
+                            moveData.type,
+                            &moveData.move.dstTmpAllocation) == VK_SUCCESS)
+                        {
+                            m_Moves.push_back(moveData.move);
+                            if (IncrementCounters(moveData.size))
+                                return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool VmaDefragmentationContext_T::ComputeDefragmentation_Extensive(VmaBlockVector& vector, size_t index)
+{
+    // First free single block, then populate it to the brim, then free another block, and so on
+
+    // Fallback to previous algorithm since without granularity conflicts it can achieve max packing
+    if (vector.m_BufferImageGranularity == 1)
+        return ComputeDefragmentation_Full(vector);
+
+    VMA_ASSERT(m_AlgorithmState != VMA_NULL);
+
+    StateExtensive& vectorState = reinterpret_cast<StateExtensive*>(m_AlgorithmState)[index];
+
+    bool texturePresent = false, bufferPresent = false, otherPresent = false;
+    switch (vectorState.operation)
+    {
+    case StateExtensive::Operation::Done: // Vector defragmented
+        return false;
+    case StateExtensive::Operation::FindFreeBlockBuffer:
+    case StateExtensive::Operation::FindFreeBlockTexture:
+    case StateExtensive::Operation::FindFreeBlockAll:
+    {
+        // No more blocks to free, just perform fast realloc and move to cleanup
+        if (vectorState.firstFreeBlock == 0)
+        {
+            vectorState.operation = StateExtensive::Operation::Cleanup;
+            return ComputeDefragmentation_Fast(vector);
+        }
+
+        // No free blocks, have to clear last one
+        size_t last = (vectorState.firstFreeBlock == SIZE_MAX ? vector.GetBlockCount() : vectorState.firstFreeBlock) - 1;
+        VmaBlockMetadata* freeMetadata = vector.GetBlock(last)->m_pMetadata;
+
+        const size_t prevMoveCount = m_Moves.size();
+        for (VmaAllocHandle handle = freeMetadata->GetAllocationListBegin();
+            handle != VK_NULL_HANDLE;
+            handle = freeMetadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, freeMetadata);
+            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                VMA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Check all previous blocks for free space
+            if (AllocInOtherBlock(0, last, moveData, vector))
+            {
+                // Full clear performed already
+                if (prevMoveCount != m_Moves.size() && freeMetadata->GetNextAllocation(handle) == VK_NULL_HANDLE)
+                    reinterpret_cast<size_t*>(m_AlgorithmState)[index] = last;
+                return true;
+            }
+        }
+
+        if (prevMoveCount == m_Moves.size())
+        {
+            // Cannot perform full clear, have to move data in other blocks around
+            if (last != 0)
+            {
+                for (size_t i = last - 1; i; --i)
+                {
+                    if (ReallocWithinBlock(vector, vector.GetBlock(i)))
+                        return true;
+                }
+            }
+
+            if (prevMoveCount == m_Moves.size())
+            {
+                // No possible reallocs within blocks, try to move them around fast
+                return ComputeDefragmentation_Fast(vector);
+            }
+        }
+        else
+        {
+            switch (vectorState.operation)
+            {
+            case StateExtensive::Operation::FindFreeBlockBuffer:
+                vectorState.operation = StateExtensive::Operation::MoveBuffers;
+                break;
+            default:
+                VMA_ASSERT(0);
+            case StateExtensive::Operation::FindFreeBlockTexture:
+                vectorState.operation = StateExtensive::Operation::MoveTextures;
+                break;
+            case StateExtensive::Operation::FindFreeBlockAll:
+                vectorState.operation = StateExtensive::Operation::MoveAll;
+                break;
+            }
+            vectorState.firstFreeBlock = last;
+            // Nothing done, block found without reallocations, can perform another reallocs in same pass
+            return ComputeDefragmentation_Extensive(vector, index);
+        }
+        break;
+    }
+    case StateExtensive::Operation::MoveTextures:
+    {
+        if (MoveDataToFreeBlocks(VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL, vector,
+            vectorState.firstFreeBlock, texturePresent, bufferPresent, otherPresent))
+        {
+            if (texturePresent)
+            {
+                vectorState.operation = StateExtensive::Operation::FindFreeBlockTexture;
+                return ComputeDefragmentation_Extensive(vector, index);
+            }
+
+            if (!bufferPresent && !otherPresent)
+            {
+                vectorState.operation = StateExtensive::Operation::Cleanup;
+                break;
+            }
+
+            // No more textures to move, check buffers
+            vectorState.operation = StateExtensive::Operation::MoveBuffers;
+            bufferPresent = false;
+            otherPresent = false;
+        }
+        else
+            break;
+    }
+    case StateExtensive::Operation::MoveBuffers:
+    {
+        if (MoveDataToFreeBlocks(VMA_SUBALLOCATION_TYPE_BUFFER, vector,
+            vectorState.firstFreeBlock, texturePresent, bufferPresent, otherPresent))
+        {
+            if (bufferPresent)
+            {
+                vectorState.operation = StateExtensive::Operation::FindFreeBlockBuffer;
+                return ComputeDefragmentation_Extensive(vector, index);
+            }
+
+            if (!otherPresent)
+            {
+                vectorState.operation = StateExtensive::Operation::Cleanup;
+                break;
+            }
+
+            // No more buffers to move, check all others
+            vectorState.operation = StateExtensive::Operation::MoveAll;
+            otherPresent = false;
+        }
+        else
+            break;
+    }
+    case StateExtensive::Operation::MoveAll:
+    {
+        if (MoveDataToFreeBlocks(VMA_SUBALLOCATION_TYPE_FREE, vector,
+            vectorState.firstFreeBlock, texturePresent, bufferPresent, otherPresent))
+        {
+            if (otherPresent)
+            {
+                vectorState.operation = StateExtensive::Operation::FindFreeBlockBuffer;
+                return ComputeDefragmentation_Extensive(vector, index);
+            }
+            // Everything moved
+            vectorState.operation = StateExtensive::Operation::Cleanup;
+        }
+        break;
+    }
+    case StateExtensive::Operation::Cleanup:
+        // Cleanup is handled below so that other operations may reuse the cleanup code. This case is here to prevent the unhandled enum value warning (C4062).
+        break;
+    }
+
+    if (vectorState.operation == StateExtensive::Operation::Cleanup)
+    {
+        // All other work done, pack data in blocks even tighter if possible
+        const size_t prevMoveCount = m_Moves.size();
+        for (size_t i = 0; i < vector.GetBlockCount(); ++i)
+        {
+            if (ReallocWithinBlock(vector, vector.GetBlock(i)))
+                return true;
+        }
+
+        if (prevMoveCount == m_Moves.size())
+            vectorState.operation = StateExtensive::Operation::Done;
+    }
+    return false;
+}
+
+void VmaDefragmentationContext_T::UpdateVectorStatistics(VmaBlockVector& vector, StateBalanced& state)
+{
+    size_t allocCount = 0;
+    size_t freeCount = 0;
+    state.avgFreeSize = 0;
+    state.avgAllocSize = 0;
+
+    for (size_t i = 0; i < vector.GetBlockCount(); ++i)
+    {
+        VmaBlockMetadata* metadata = vector.GetBlock(i)->m_pMetadata;
+
+        allocCount += metadata->GetAllocationCount();
+        freeCount += metadata->GetFreeRegionsCount();
+        state.avgFreeSize += metadata->GetSumFreeSize();
+        state.avgAllocSize += metadata->GetSize();
+    }
+
+    state.avgAllocSize = (state.avgAllocSize - state.avgFreeSize) / allocCount;
+    state.avgFreeSize /= freeCount;
+}
+
+bool VmaDefragmentationContext_T::MoveDataToFreeBlocks(VmaSuballocationType currentType, 
+    VmaBlockVector& vector, size_t firstFreeBlock,
+    bool& texturePresent, bool& bufferPresent, bool& otherPresent)
+{
+    const size_t prevMoveCount = m_Moves.size();
+    for (size_t i = firstFreeBlock ; i;)
+    {
+        VmaDeviceMemoryBlock* block = vector.GetBlock(--i);
+        VmaBlockMetadata* metadata = block->m_pMetadata;
+
+        for (VmaAllocHandle handle = metadata->GetAllocationListBegin();
+            handle != VK_NULL_HANDLE;
+            handle = metadata->GetNextAllocation(handle))
+        {
+            MoveAllocationData moveData = GetMoveData(handle, metadata);
+            // Ignore newly created allocations by defragmentation algorithm
+            if (moveData.move.srcAllocation->GetUserData() == this)
+                continue;
+            switch (CheckCounters(moveData.move.srcAllocation->GetSize()))
+            {
+            case CounterStatus::Ignore:
+                continue;
+            case CounterStatus::End:
+                return true;
+            default:
+                VMA_ASSERT(0);
+            case CounterStatus::Pass:
+                break;
+            }
+
+            // Move only single type of resources at once
+            if (!VmaIsBufferImageGranularityConflict(moveData.type, currentType))
+            {
+                // Try to fit allocation into free blocks
+                if (AllocInOtherBlock(firstFreeBlock, vector.GetBlockCount(), moveData, vector))
+                    return false;
+            }
+
+            if (!VmaIsBufferImageGranularityConflict(moveData.type, VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL))
+                texturePresent = true;
+            else if (!VmaIsBufferImageGranularityConflict(moveData.type, VMA_SUBALLOCATION_TYPE_BUFFER))
+                bufferPresent = true;
+            else
+                otherPresent = true;
+        }
+    }
+    return prevMoveCount == m_Moves.size();
+}
+#endif // _VMA_DEFRAGMENTATION_CONTEXT_FUNCTIONS
+
+#ifndef _VMA_POOL_T_FUNCTIONS
+VmaPool_T::VmaPool_T(
+    VmaAllocator hAllocator,
+    const VmaPoolCreateInfo& createInfo,
+    VkDeviceSize preferredBlockSize)
+    : m_BlockVector(
+        hAllocator,
+        this, // hParentPool
+        createInfo.memoryTypeIndex,
+        createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
+        createInfo.minBlockCount,
+        createInfo.maxBlockCount,
+        (createInfo.flags& VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
+        createInfo.blockSize != 0, // explicitBlockSize
+        createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK, // algorithm
+        createInfo.priority,
+        VMA_MAX(hAllocator->GetMemoryTypeMinAlignment(createInfo.memoryTypeIndex), createInfo.minAllocationAlignment),
+        createInfo.pMemoryAllocateNext),
+    m_Id(0),
+    m_Name(VMA_NULL) {}
+
+VmaPool_T::~VmaPool_T()
+{
+    VMA_ASSERT(m_PrevPool == VMA_NULL && m_NextPool == VMA_NULL);
+}
+
+void VmaPool_T::SetName(const char* pName)
+{
+    const VkAllocationCallbacks* allocs = m_BlockVector.GetAllocator()->GetAllocationCallbacks();
+    VmaFreeString(allocs, m_Name);
+
+    if (pName != VMA_NULL)
+    {
+        m_Name = VmaCreateStringCopy(allocs, pName);
+    }
+    else
+    {
+        m_Name = VMA_NULL;
+    }
+}
+#endif // _VMA_POOL_T_FUNCTIONS
+
+#ifndef _VMA_ALLOCATOR_T_FUNCTIONS
+VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
+    m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
+    m_VulkanApiVersion(pCreateInfo->vulkanApiVersion != 0 ? pCreateInfo->vulkanApiVersion : VK_API_VERSION_1_0),
+    m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
+    m_UseKhrBindMemory2((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0),
+    m_UseExtMemoryBudget((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0),
+    m_UseAmdDeviceCoherentMemory((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT) != 0),
+    m_UseKhrBufferDeviceAddress((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT) != 0),
+    m_UseExtMemoryPriority((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT) != 0),
+    m_hDevice(pCreateInfo->device),
+    m_hInstance(pCreateInfo->instance),
+    m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
+    m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
+        *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
+    m_AllocationObjectAllocator(&m_AllocationCallbacks),
+    m_HeapSizeLimitMask(0),
+    m_DeviceMemoryCount(0),
+    m_PreferredLargeHeapBlockSize(0),
+    m_PhysicalDevice(pCreateInfo->physicalDevice),
+    m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),
+    m_NextPoolId(0),
+    m_GlobalMemoryTypeBits(UINT32_MAX)
+{
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        m_UseKhrDedicatedAllocation = false;
+        m_UseKhrBindMemory2 = false;
+    }
+
+    if(VMA_DEBUG_DETECT_CORRUPTION)
+    {
+        // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
+        VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
+    }
+
+    VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device && pCreateInfo->instance);
+
+    if(m_VulkanApiVersion < VK_MAKE_VERSION(1, 1, 0))
+    {
+#if !(VMA_DEDICATED_ALLOCATION)
+        if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
+        {
+            VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
+        }
+#endif
+#if !(VMA_BIND_MEMORY2)
+        if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
+        {
+            VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT set but required extension is disabled by preprocessor macros.");
+        }
+#endif
+    }
+#if !(VMA_MEMORY_BUDGET)
+    if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT set but required extension is disabled by preprocessor macros.");
+    }
+#endif
+#if !(VMA_BUFFER_DEVICE_ADDRESS)
+    if(m_UseKhrBufferDeviceAddress)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT is set but required extension or Vulkan 1.2 is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
+    }
+#endif
+#if VMA_VULKAN_VERSION < 1002000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 2, 0))
+    {
+        VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_2 but required Vulkan version is disabled by preprocessor macros.");
+    }
+#endif
+#if VMA_VULKAN_VERSION < 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VMA_ASSERT(0 && "vulkanApiVersion >= VK_API_VERSION_1_1 but required Vulkan version is disabled by preprocessor macros.");
+    }
+#endif
+#if !(VMA_MEMORY_PRIORITY)
+    if(m_UseExtMemoryPriority)
+    {
+        VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT is set but required extension is not available in your Vulkan header or its support in VMA has been disabled by a preprocessor macro.");
+    }
+#endif
+
+    memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
+    memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
+    memset(&m_MemProps, 0, sizeof(m_MemProps));
+
+    memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
+    memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));
+
+#if VMA_EXTERNAL_MEMORY
+    memset(&m_TypeExternalMemoryHandleTypes, 0, sizeof(m_TypeExternalMemoryHandleTypes));
+#endif // #if VMA_EXTERNAL_MEMORY
+
+    if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
+    {
+        m_DeviceMemoryCallbacks.pUserData = pCreateInfo->pDeviceMemoryCallbacks->pUserData;
+        m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
+        m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
+    }
+
+    ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
+
+    (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
+    (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
+
+    VMA_ASSERT(VmaIsPow2(VMA_MIN_ALIGNMENT));
+    VMA_ASSERT(VmaIsPow2(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY));
+    VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.bufferImageGranularity));
+    VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.nonCoherentAtomSize));
+
+    m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
+        pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
+
+    m_GlobalMemoryTypeBits = CalculateGlobalMemoryTypeBits();
+
+#if VMA_EXTERNAL_MEMORY
+    if(pCreateInfo->pTypeExternalMemoryHandleTypes != VMA_NULL)
+    {
+        memcpy(m_TypeExternalMemoryHandleTypes, pCreateInfo->pTypeExternalMemoryHandleTypes,
+            sizeof(VkExternalMemoryHandleTypeFlagsKHR) * GetMemoryTypeCount());
+    }
+#endif // #if VMA_EXTERNAL_MEMORY
+
+    if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
+    {
+        for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
+        {
+            const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
+            if(limit != VK_WHOLE_SIZE)
+            {
+                m_HeapSizeLimitMask |= 1u << heapIndex;
+                if(limit < m_MemProps.memoryHeaps[heapIndex].size)
+                {
+                    m_MemProps.memoryHeaps[heapIndex].size = limit;
+                }
+            }
+        }
+    }
+
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        // Create only supported types
+        if((m_GlobalMemoryTypeBits & (1u << memTypeIndex)) != 0)
+        {
+            const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
+            m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
+                this,
+                VK_NULL_HANDLE, // hParentPool
+                memTypeIndex,
+                preferredBlockSize,
+                0,
+                SIZE_MAX,
+                GetBufferImageGranularity(),
+                false, // explicitBlockSize
+                0, // algorithm
+                0.5f, // priority (0.5 is the default per Vulkan spec)
+                GetMemoryTypeMinAlignment(memTypeIndex), // minAllocationAlignment
+                VMA_NULL); // // pMemoryAllocateNext
+            // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
+            // becase minBlockCount is 0.
+        }
+    }
+}
+
+VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
+{
+    VkResult res = VK_SUCCESS;
+
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        UpdateVulkanBudget();
+    }
+#endif // #if VMA_MEMORY_BUDGET
+
+    return res;
+}
+
+VmaAllocator_T::~VmaAllocator_T()
+{
+    VMA_ASSERT(m_Pools.IsEmpty());
+
+    for(size_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
+    {
+        vma_delete(this, m_pBlockVectors[memTypeIndex]);
+    }
+}
+
+void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
+{
+#if VMA_STATIC_VULKAN_FUNCTIONS == 1
+    ImportVulkanFunctions_Static();
+#endif
+
+    if(pVulkanFunctions != VMA_NULL)
+    {
+        ImportVulkanFunctions_Custom(pVulkanFunctions);
+    }
+
+#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+    ImportVulkanFunctions_Dynamic();
+#endif
+
+    ValidateVulkanFunctions();
+}
+
+#if VMA_STATIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ImportVulkanFunctions_Static()
+{
+    // Vulkan 1.0
+    m_VulkanFunctions.vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)vkGetInstanceProcAddr;
+    m_VulkanFunctions.vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)vkGetDeviceProcAddr;
+    m_VulkanFunctions.vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)vkGetPhysicalDeviceProperties;
+    m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vkGetPhysicalDeviceMemoryProperties;
+    m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
+    m_VulkanFunctions.vkFreeMemory = (PFN_vkFreeMemory)vkFreeMemory;
+    m_VulkanFunctions.vkMapMemory = (PFN_vkMapMemory)vkMapMemory;
+    m_VulkanFunctions.vkUnmapMemory = (PFN_vkUnmapMemory)vkUnmapMemory;
+    m_VulkanFunctions.vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)vkFlushMappedMemoryRanges;
+    m_VulkanFunctions.vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)vkInvalidateMappedMemoryRanges;
+    m_VulkanFunctions.vkBindBufferMemory = (PFN_vkBindBufferMemory)vkBindBufferMemory;
+    m_VulkanFunctions.vkBindImageMemory = (PFN_vkBindImageMemory)vkBindImageMemory;
+    m_VulkanFunctions.vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)vkGetBufferMemoryRequirements;
+    m_VulkanFunctions.vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vkGetImageMemoryRequirements;
+    m_VulkanFunctions.vkCreateBuffer = (PFN_vkCreateBuffer)vkCreateBuffer;
+    m_VulkanFunctions.vkDestroyBuffer = (PFN_vkDestroyBuffer)vkDestroyBuffer;
+    m_VulkanFunctions.vkCreateImage = (PFN_vkCreateImage)vkCreateImage;
+    m_VulkanFunctions.vkDestroyImage = (PFN_vkDestroyImage)vkDestroyImage;
+    m_VulkanFunctions.vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)vkCmdCopyBuffer;
+
+    // Vulkan 1.1
+#if VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2)vkGetBufferMemoryRequirements2;
+        m_VulkanFunctions.vkGetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2)vkGetImageMemoryRequirements2;
+        m_VulkanFunctions.vkBindBufferMemory2KHR = (PFN_vkBindBufferMemory2)vkBindBufferMemory2;
+        m_VulkanFunctions.vkBindImageMemory2KHR = (PFN_vkBindImageMemory2)vkBindImageMemory2;
+        m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2)vkGetPhysicalDeviceMemoryProperties2;
+    }
+#endif
+
+#if VMA_VULKAN_VERSION >= 1003000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
+    {
+        m_VulkanFunctions.vkGetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)vkGetDeviceBufferMemoryRequirements;
+        m_VulkanFunctions.vkGetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)vkGetDeviceImageMemoryRequirements;
+    }
+#endif
+}
+
+#endif // VMA_STATIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ImportVulkanFunctions_Custom(const VmaVulkanFunctions* pVulkanFunctions)
+{
+    VMA_ASSERT(pVulkanFunctions != VMA_NULL);
+
+#define VMA_COPY_IF_NOT_NULL(funcName) \
+    if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
+
+    VMA_COPY_IF_NOT_NULL(vkGetInstanceProcAddr);
+    VMA_COPY_IF_NOT_NULL(vkGetDeviceProcAddr);
+    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
+    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
+    VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
+    VMA_COPY_IF_NOT_NULL(vkFreeMemory);
+    VMA_COPY_IF_NOT_NULL(vkMapMemory);
+    VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
+    VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
+    VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
+    VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
+    VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
+    VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
+    VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
+    VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
+    VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
+    VMA_COPY_IF_NOT_NULL(vkCreateImage);
+    VMA_COPY_IF_NOT_NULL(vkDestroyImage);
+    VMA_COPY_IF_NOT_NULL(vkCmdCopyBuffer);
+
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
+    VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
+#endif
+
+#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
+    VMA_COPY_IF_NOT_NULL(vkBindBufferMemory2KHR);
+    VMA_COPY_IF_NOT_NULL(vkBindImageMemory2KHR);
+#endif
+
+#if VMA_MEMORY_BUDGET
+    VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
+#endif
+
+#if VMA_VULKAN_VERSION >= 1003000
+    VMA_COPY_IF_NOT_NULL(vkGetDeviceBufferMemoryRequirements);
+    VMA_COPY_IF_NOT_NULL(vkGetDeviceImageMemoryRequirements);
+#endif
+
+#undef VMA_COPY_IF_NOT_NULL
+}
+
+#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ImportVulkanFunctions_Dynamic()
+{
+    VMA_ASSERT(m_VulkanFunctions.vkGetInstanceProcAddr && m_VulkanFunctions.vkGetDeviceProcAddr &&
+        "To use VMA_DYNAMIC_VULKAN_FUNCTIONS in new versions of VMA you now have to pass "
+        "VmaVulkanFunctions::vkGetInstanceProcAddr and vkGetDeviceProcAddr as VmaAllocatorCreateInfo::pVulkanFunctions. "
+        "Other members can be null.");
+
+#define VMA_FETCH_INSTANCE_FUNC(memberName, functionPointerType, functionNameString) \
+    if(m_VulkanFunctions.memberName == VMA_NULL) \
+        m_VulkanFunctions.memberName = \
+            (functionPointerType)m_VulkanFunctions.vkGetInstanceProcAddr(m_hInstance, functionNameString);
+#define VMA_FETCH_DEVICE_FUNC(memberName, functionPointerType, functionNameString) \
+    if(m_VulkanFunctions.memberName == VMA_NULL) \
+        m_VulkanFunctions.memberName = \
+            (functionPointerType)m_VulkanFunctions.vkGetDeviceProcAddr(m_hDevice, functionNameString);
+
+    VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceProperties, PFN_vkGetPhysicalDeviceProperties, "vkGetPhysicalDeviceProperties");
+    VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties, PFN_vkGetPhysicalDeviceMemoryProperties, "vkGetPhysicalDeviceMemoryProperties");
+    VMA_FETCH_DEVICE_FUNC(vkAllocateMemory, PFN_vkAllocateMemory, "vkAllocateMemory");
+    VMA_FETCH_DEVICE_FUNC(vkFreeMemory, PFN_vkFreeMemory, "vkFreeMemory");
+    VMA_FETCH_DEVICE_FUNC(vkMapMemory, PFN_vkMapMemory, "vkMapMemory");
+    VMA_FETCH_DEVICE_FUNC(vkUnmapMemory, PFN_vkUnmapMemory, "vkUnmapMemory");
+    VMA_FETCH_DEVICE_FUNC(vkFlushMappedMemoryRanges, PFN_vkFlushMappedMemoryRanges, "vkFlushMappedMemoryRanges");
+    VMA_FETCH_DEVICE_FUNC(vkInvalidateMappedMemoryRanges, PFN_vkInvalidateMappedMemoryRanges, "vkInvalidateMappedMemoryRanges");
+    VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory, PFN_vkBindBufferMemory, "vkBindBufferMemory");
+    VMA_FETCH_DEVICE_FUNC(vkBindImageMemory, PFN_vkBindImageMemory, "vkBindImageMemory");
+    VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements, PFN_vkGetBufferMemoryRequirements, "vkGetBufferMemoryRequirements");
+    VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements, PFN_vkGetImageMemoryRequirements, "vkGetImageMemoryRequirements");
+    VMA_FETCH_DEVICE_FUNC(vkCreateBuffer, PFN_vkCreateBuffer, "vkCreateBuffer");
+    VMA_FETCH_DEVICE_FUNC(vkDestroyBuffer, PFN_vkDestroyBuffer, "vkDestroyBuffer");
+    VMA_FETCH_DEVICE_FUNC(vkCreateImage, PFN_vkCreateImage, "vkCreateImage");
+    VMA_FETCH_DEVICE_FUNC(vkDestroyImage, PFN_vkDestroyImage, "vkDestroyImage");
+    VMA_FETCH_DEVICE_FUNC(vkCmdCopyBuffer, PFN_vkCmdCopyBuffer, "vkCmdCopyBuffer");
+
+#if VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements2KHR, PFN_vkGetBufferMemoryRequirements2, "vkGetBufferMemoryRequirements2");
+        VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements2KHR, PFN_vkGetImageMemoryRequirements2, "vkGetImageMemoryRequirements2");
+        VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory2KHR, PFN_vkBindBufferMemory2, "vkBindBufferMemory2");
+        VMA_FETCH_DEVICE_FUNC(vkBindImageMemory2KHR, PFN_vkBindImageMemory2, "vkBindImageMemory2");
+        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2, "vkGetPhysicalDeviceMemoryProperties2");
+    }
+#endif
+
+#if VMA_DEDICATED_ALLOCATION
+    if(m_UseKhrDedicatedAllocation)
+    {
+        VMA_FETCH_DEVICE_FUNC(vkGetBufferMemoryRequirements2KHR, PFN_vkGetBufferMemoryRequirements2KHR, "vkGetBufferMemoryRequirements2KHR");
+        VMA_FETCH_DEVICE_FUNC(vkGetImageMemoryRequirements2KHR, PFN_vkGetImageMemoryRequirements2KHR, "vkGetImageMemoryRequirements2KHR");
+    }
+#endif
+
+#if VMA_BIND_MEMORY2
+    if(m_UseKhrBindMemory2)
+    {
+        VMA_FETCH_DEVICE_FUNC(vkBindBufferMemory2KHR, PFN_vkBindBufferMemory2KHR, "vkBindBufferMemory2KHR");
+        VMA_FETCH_DEVICE_FUNC(vkBindImageMemory2KHR, PFN_vkBindImageMemory2KHR, "vkBindImageMemory2KHR");
+    }
+#endif // #if VMA_BIND_MEMORY2
+
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        VMA_FETCH_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, PFN_vkGetPhysicalDeviceMemoryProperties2KHR, "vkGetPhysicalDeviceMemoryProperties2KHR");
+    }
+#endif // #if VMA_MEMORY_BUDGET
+
+#if VMA_VULKAN_VERSION >= 1003000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
+    {
+        VMA_FETCH_DEVICE_FUNC(vkGetDeviceBufferMemoryRequirements, PFN_vkGetDeviceBufferMemoryRequirements, "vkGetDeviceBufferMemoryRequirements");
+        VMA_FETCH_DEVICE_FUNC(vkGetDeviceImageMemoryRequirements, PFN_vkGetDeviceImageMemoryRequirements, "vkGetDeviceImageMemoryRequirements");
+    }
+#endif
+
+#undef VMA_FETCH_DEVICE_FUNC
+#undef VMA_FETCH_INSTANCE_FUNC
+}
+
+#endif // VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
+
+void VmaAllocator_T::ValidateVulkanFunctions()
+{
+    VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
+    VMA_ASSERT(m_VulkanFunctions.vkCmdCopyBuffer != VMA_NULL);
+
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrDedicatedAllocation)
+    {
+        VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
+        VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
+    }
+#endif
+
+#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0) || m_UseKhrBindMemory2)
+    {
+        VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL);
+        VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL);
+    }
+#endif
+
+#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
+    if(m_UseExtMemoryBudget || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
+    }
+#endif
+
+#if VMA_VULKAN_VERSION >= 1003000
+    if(m_VulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
+    {
+        VMA_ASSERT(m_VulkanFunctions.vkGetDeviceBufferMemoryRequirements != VMA_NULL);
+        VMA_ASSERT(m_VulkanFunctions.vkGetDeviceImageMemoryRequirements != VMA_NULL);
+    }
+#endif
+}
+
+VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
+{
+    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
+    const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
+    const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
+    return VmaAlignUp(isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize, (VkDeviceSize)32);
+}
+
+VkResult VmaAllocator_T::AllocateMemoryOfType(
+    VmaPool pool,
+    VkDeviceSize size,
+    VkDeviceSize alignment,
+    bool dedicatedPreferred,
+    VkBuffer dedicatedBuffer,
+    VkImage dedicatedImage,
+    VkFlags dedicatedBufferImageUsage,
+    const VmaAllocationCreateInfo& createInfo,
+    uint32_t memTypeIndex,
+    VmaSuballocationType suballocType,
+    VmaDedicatedAllocationList& dedicatedAllocations,
+    VmaBlockVector& blockVector,
+    size_t allocationCount,
+    VmaAllocation* pAllocations)
+{
+    VMA_ASSERT(pAllocations != VMA_NULL);
+    VMA_DEBUG_LOG("  AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);
+
+    VmaAllocationCreateInfo finalCreateInfo = createInfo;
+    VkResult res = CalcMemTypeParams(
+        finalCreateInfo,
+        memTypeIndex,
+        size,
+        allocationCount);
+    if(res != VK_SUCCESS)
+        return res;
+
+    if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
+    {
+        return AllocateDedicatedMemory(
+            pool,
+            size,
+            suballocType,
+            dedicatedAllocations,
+            memTypeIndex,
+            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
+            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
+            (finalCreateInfo.flags &
+                (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
+            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
+            finalCreateInfo.pUserData,
+            finalCreateInfo.priority,
+            dedicatedBuffer,
+            dedicatedImage,
+            dedicatedBufferImageUsage,
+            allocationCount,
+            pAllocations,
+            blockVector.GetAllocationNextPtr());
+    }
+    else
+    {
+        const bool canAllocateDedicated =
+            (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
+            (pool == VK_NULL_HANDLE || !blockVector.HasExplicitBlockSize());
+
+        if(canAllocateDedicated)
+        {
+            // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
+            if(size > blockVector.GetPreferredBlockSize() / 2)
+            {
+                dedicatedPreferred = true;
+            }
+            // Protection against creating each allocation as dedicated when we reach or exceed heap size/budget,
+            // which can quickly deplete maxMemoryAllocationCount: Don't prefer dedicated allocations when above
+            // 3/4 of the maximum allocation count.
+            if(m_DeviceMemoryCount.load() > m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount * 3 / 4)
+            {
+                dedicatedPreferred = false;
+            }
+
+            if(dedicatedPreferred)
+            {
+                res = AllocateDedicatedMemory(
+                    pool,
+                    size,
+                    suballocType,
+                    dedicatedAllocations,
+                    memTypeIndex,
+                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
+                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
+                    (finalCreateInfo.flags &
+                        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
+                    (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
+                    finalCreateInfo.pUserData,
+                    finalCreateInfo.priority,
+                    dedicatedBuffer,
+                    dedicatedImage,
+                    dedicatedBufferImageUsage,
+                    allocationCount,
+                    pAllocations,
+                    blockVector.GetAllocationNextPtr());
+                if(res == VK_SUCCESS)
+                {
+                    // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
+                    VMA_DEBUG_LOG("    Allocated as DedicatedMemory");
+                    return VK_SUCCESS;
+                }
+            }
+        }
+
+        res = blockVector.Allocate(
+            size,
+            alignment,
+            finalCreateInfo,
+            suballocType,
+            allocationCount,
+            pAllocations);
+        if(res == VK_SUCCESS)
+            return VK_SUCCESS;
+
+        // Try dedicated memory.
+        if(canAllocateDedicated && !dedicatedPreferred)
+        {
+            res = AllocateDedicatedMemory(
+                pool,
+                size,
+                suballocType,
+                dedicatedAllocations,
+                memTypeIndex,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
+                (finalCreateInfo.flags &
+                    (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
+                finalCreateInfo.pUserData,
+                finalCreateInfo.priority,
+                dedicatedBuffer,
+                dedicatedImage,
+                dedicatedBufferImageUsage,
+                allocationCount,
+                pAllocations,
+                blockVector.GetAllocationNextPtr());
+            if(res == VK_SUCCESS)
+            {
+                // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
+                VMA_DEBUG_LOG("    Allocated as DedicatedMemory");
+                return VK_SUCCESS;
+            }
+        }
+        // Everything failed: Return error code.
+        VMA_DEBUG_LOG("    vkAllocateMemory FAILED");
+        return res;
+    }
+}
+
+VkResult VmaAllocator_T::AllocateDedicatedMemory(
+    VmaPool pool,
+    VkDeviceSize size,
+    VmaSuballocationType suballocType,
+    VmaDedicatedAllocationList& dedicatedAllocations,
+    uint32_t memTypeIndex,
+    bool map,
+    bool isUserDataString,
+    bool isMappingAllowed,
+    bool canAliasMemory,
+    void* pUserData,
+    float priority,
+    VkBuffer dedicatedBuffer,
+    VkImage dedicatedImage,
+    VkFlags dedicatedBufferImageUsage,
+    size_t allocationCount,
+    VmaAllocation* pAllocations,
+    const void* pNextChain)
+{
+    VMA_ASSERT(allocationCount > 0 && pAllocations);
+
+    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+    allocInfo.memoryTypeIndex = memTypeIndex;
+    allocInfo.allocationSize = size;
+    allocInfo.pNext = pNextChain;
+
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
+    if(!canAliasMemory)
+    {
+        if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+        {
+            if(dedicatedBuffer != VK_NULL_HANDLE)
+            {
+                VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
+                dedicatedAllocInfo.buffer = dedicatedBuffer;
+                VmaPnextChainPushFront(&allocInfo, &dedicatedAllocInfo);
+            }
+            else if(dedicatedImage != VK_NULL_HANDLE)
+            {
+                dedicatedAllocInfo.image = dedicatedImage;
+                VmaPnextChainPushFront(&allocInfo, &dedicatedAllocInfo);
+            }
+        }
+    }
+#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+
+#if VMA_BUFFER_DEVICE_ADDRESS
+    VkMemoryAllocateFlagsInfoKHR allocFlagsInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR };
+    if(m_UseKhrBufferDeviceAddress)
+    {
+        bool canContainBufferWithDeviceAddress = true;
+        if(dedicatedBuffer != VK_NULL_HANDLE)
+        {
+            canContainBufferWithDeviceAddress = dedicatedBufferImageUsage == UINT32_MAX || // Usage flags unknown
+                (dedicatedBufferImageUsage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT) != 0;
+        }
+        else if(dedicatedImage != VK_NULL_HANDLE)
+        {
+            canContainBufferWithDeviceAddress = false;
+        }
+        if(canContainBufferWithDeviceAddress)
+        {
+            allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
+            VmaPnextChainPushFront(&allocInfo, &allocFlagsInfo);
+        }
+    }
+#endif // #if VMA_BUFFER_DEVICE_ADDRESS
+
+#if VMA_MEMORY_PRIORITY
+    VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
+    if(m_UseExtMemoryPriority)
+    {
+        VMA_ASSERT(priority >= 0.f && priority <= 1.f);
+        priorityInfo.priority = priority;
+        VmaPnextChainPushFront(&allocInfo, &priorityInfo);
+    }
+#endif // #if VMA_MEMORY_PRIORITY
+
+#if VMA_EXTERNAL_MEMORY
+    // Attach VkExportMemoryAllocateInfoKHR if necessary.
+    VkExportMemoryAllocateInfoKHR exportMemoryAllocInfo = { VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR };
+    exportMemoryAllocInfo.handleTypes = GetExternalMemoryHandleTypeFlags(memTypeIndex);
+    if(exportMemoryAllocInfo.handleTypes != 0)
+    {
+        VmaPnextChainPushFront(&allocInfo, &exportMemoryAllocInfo);
+    }
+#endif // #if VMA_EXTERNAL_MEMORY
+
+    size_t allocIndex;
+    VkResult res = VK_SUCCESS;
+    for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+    {
+        res = AllocateDedicatedMemoryPage(
+            pool,
+            size,
+            suballocType,
+            memTypeIndex,
+            allocInfo,
+            map,
+            isUserDataString,
+            isMappingAllowed,
+            pUserData,
+            pAllocations + allocIndex);
+        if(res != VK_SUCCESS)
+        {
+            break;
+        }
+    }
+
+    if(res == VK_SUCCESS)
+    {
+        for (allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+        {
+            dedicatedAllocations.Register(pAllocations[allocIndex]);
+        }
+        VMA_DEBUG_LOG("    Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
+    }
+    else
+    {
+        // Free all already created allocations.
+        while(allocIndex--)
+        {
+            VmaAllocation currAlloc = pAllocations[allocIndex];
+            VkDeviceMemory hMemory = currAlloc->GetMemory();
+
+            /*
+            There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
+            before vkFreeMemory.
+
+            if(currAlloc->GetMappedData() != VMA_NULL)
+            {
+                (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
+            }
+            */
+
+            FreeVulkanMemory(memTypeIndex, currAlloc->GetSize(), hMemory);
+            m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), currAlloc->GetSize());
+            m_AllocationObjectAllocator.Free(currAlloc);
+        }
+
+        memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
+    }
+
+    return res;
+}
+
+VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(
+    VmaPool pool,
+    VkDeviceSize size,
+    VmaSuballocationType suballocType,
+    uint32_t memTypeIndex,
+    const VkMemoryAllocateInfo& allocInfo,
+    bool map,
+    bool isUserDataString,
+    bool isMappingAllowed,
+    void* pUserData,
+    VmaAllocation* pAllocation)
+{
+    VkDeviceMemory hMemory = VK_NULL_HANDLE;
+    VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
+    if(res < 0)
+    {
+        VMA_DEBUG_LOG("    vkAllocateMemory FAILED");
+        return res;
+    }
+
+    void* pMappedData = VMA_NULL;
+    if(map)
+    {
+        res = (*m_VulkanFunctions.vkMapMemory)(
+            m_hDevice,
+            hMemory,
+            0,
+            VK_WHOLE_SIZE,
+            0,
+            &pMappedData);
+        if(res < 0)
+        {
+            VMA_DEBUG_LOG("    vkMapMemory FAILED");
+            FreeVulkanMemory(memTypeIndex, size, hMemory);
+            return res;
+        }
+    }
+
+    *pAllocation = m_AllocationObjectAllocator.Allocate(isMappingAllowed);
+    (*pAllocation)->InitDedicatedAllocation(pool, memTypeIndex, hMemory, suballocType, pMappedData, size);
+    if (isUserDataString)
+        (*pAllocation)->SetName(this, (const char*)pUserData);
+    else
+        (*pAllocation)->SetUserData(this, pUserData);
+    m_Budget.AddAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), size);
+    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
+    {
+        FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaAllocator_T::GetBufferMemoryRequirements(
+    VkBuffer hBuffer,
+    VkMemoryRequirements& memReq,
+    bool& requiresDedicatedAllocation,
+    bool& prefersDedicatedAllocation) const
+{
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
+        memReqInfo.buffer = hBuffer;
+
+        VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
+
+        VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
+        VmaPnextChainPushFront(&memReq2, &memDedicatedReq);
+
+        (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
+
+        memReq = memReq2.memoryRequirements;
+        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
+        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);
+    }
+    else
+#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    {
+        (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
+        requiresDedicatedAllocation = false;
+        prefersDedicatedAllocation  = false;
+    }
+}
+
+void VmaAllocator_T::GetImageMemoryRequirements(
+    VkImage hImage,
+    VkMemoryRequirements& memReq,
+    bool& requiresDedicatedAllocation,
+    bool& prefersDedicatedAllocation) const
+{
+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    if(m_UseKhrDedicatedAllocation || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+    {
+        VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
+        memReqInfo.image = hImage;
+
+        VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
+
+        VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
+        VmaPnextChainPushFront(&memReq2, &memDedicatedReq);
+
+        (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
+
+        memReq = memReq2.memoryRequirements;
+        requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
+        prefersDedicatedAllocation  = (memDedicatedReq.prefersDedicatedAllocation  != VK_FALSE);
+    }
+    else
+#endif // #if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000
+    {
+        (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
+        requiresDedicatedAllocation = false;
+        prefersDedicatedAllocation  = false;
+    }
+}
+
+VkResult VmaAllocator_T::FindMemoryTypeIndex(
+    uint32_t memoryTypeBits,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    VkFlags bufImgUsage,
+    uint32_t* pMemoryTypeIndex) const
+{
+    memoryTypeBits &= GetGlobalMemoryTypeBits();
+
+    if(pAllocationCreateInfo->memoryTypeBits != 0)
+    {
+        memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
+    }
+
+    VkMemoryPropertyFlags requiredFlags = 0, preferredFlags = 0, notPreferredFlags = 0;
+    if(!FindMemoryPreferences(
+        IsIntegratedGpu(),
+        *pAllocationCreateInfo,
+        bufImgUsage,
+        requiredFlags, preferredFlags, notPreferredFlags))
+    {
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    *pMemoryTypeIndex = UINT32_MAX;
+    uint32_t minCost = UINT32_MAX;
+    for(uint32_t memTypeIndex = 0, memTypeBit = 1;
+        memTypeIndex < GetMemoryTypeCount();
+        ++memTypeIndex, memTypeBit <<= 1)
+    {
+        // This memory type is acceptable according to memoryTypeBits bitmask.
+        if((memTypeBit & memoryTypeBits) != 0)
+        {
+            const VkMemoryPropertyFlags currFlags =
+                m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
+            // This memory type contains requiredFlags.
+            if((requiredFlags & ~currFlags) == 0)
+            {
+                // Calculate cost as number of bits from preferredFlags not present in this memory type.
+                uint32_t currCost = VMA_COUNT_BITS_SET(preferredFlags & ~currFlags) +
+                    VMA_COUNT_BITS_SET(currFlags & notPreferredFlags);
+                // Remember memory type with lowest cost.
+                if(currCost < minCost)
+                {
+                    *pMemoryTypeIndex = memTypeIndex;
+                    if(currCost == 0)
+                    {
+                        return VK_SUCCESS;
+                    }
+                    minCost = currCost;
+                }
+            }
+        }
+    }
+    return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
+}
+
+VkResult VmaAllocator_T::CalcMemTypeParams(
+    VmaAllocationCreateInfo& inoutCreateInfo,
+    uint32_t memTypeIndex,
+    VkDeviceSize size,
+    size_t allocationCount)
+{
+    // If memory type is not HOST_VISIBLE, disable MAPPED.
+    if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
+        (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
+    {
+        inoutCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
+    }
+
+    if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
+        (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0)
+    {
+        const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
+        VmaBudget heapBudget = {};
+        GetHeapBudgets(&heapBudget, heapIndex, 1);
+        if(heapBudget.usage + size * allocationCount > heapBudget.budget)
+        {
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+    }
+    return VK_SUCCESS;
+}
+
+VkResult VmaAllocator_T::CalcAllocationParams(
+    VmaAllocationCreateInfo& inoutCreateInfo,
+    bool dedicatedRequired,
+    bool dedicatedPreferred)
+{
+    VMA_ASSERT((inoutCreateInfo.flags &
+        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) !=
+        (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT) &&
+        "Specifying both flags VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT and VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT is incorrect.");
+    VMA_ASSERT((((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT) == 0 ||
+        (inoutCreateInfo.flags & (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0)) &&
+        "Specifying VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT requires also VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.");
+    if(inoutCreateInfo.usage == VMA_MEMORY_USAGE_AUTO || inoutCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE || inoutCreateInfo.usage == VMA_MEMORY_USAGE_AUTO_PREFER_HOST)
+    {
+        if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0)
+        {
+            VMA_ASSERT((inoutCreateInfo.flags & (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0 &&
+                "When using VMA_ALLOCATION_CREATE_MAPPED_BIT and usage = VMA_MEMORY_USAGE_AUTO*, you must also specify VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.");
+        }
+    }
+
+    // If memory is lazily allocated, it should be always dedicated.
+    if(dedicatedRequired ||
+        inoutCreateInfo.usage == VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED)
+    {
+        inoutCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+    }
+
+    if(inoutCreateInfo.pool != VK_NULL_HANDLE)
+    {
+        if(inoutCreateInfo.pool->m_BlockVector.HasExplicitBlockSize() &&
+            (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
+        {
+            VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT while current custom pool doesn't support dedicated allocations.");
+            return VK_ERROR_FEATURE_NOT_PRESENT;
+        }
+        inoutCreateInfo.priority = inoutCreateInfo.pool->m_BlockVector.GetPriority();
+    }
+
+    if((inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
+        (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
+    {
+        VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    if(VMA_DEBUG_ALWAYS_DEDICATED_MEMORY &&
+        (inoutCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
+    {
+        inoutCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+    }
+
+    // Non-auto USAGE values imply HOST_ACCESS flags.
+    // And so does VMA_MEMORY_USAGE_UNKNOWN because it is used with custom pools.
+    // Which specific flag is used doesn't matter. They change things only when used with VMA_MEMORY_USAGE_AUTO*.
+    // Otherwise they just protect from assert on mapping.
+    if(inoutCreateInfo.usage != VMA_MEMORY_USAGE_AUTO &&
+        inoutCreateInfo.usage != VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE &&
+        inoutCreateInfo.usage != VMA_MEMORY_USAGE_AUTO_PREFER_HOST)
+    {
+        if((inoutCreateInfo.flags & (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) == 0)
+        {
+            inoutCreateInfo.flags |= VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
+        }
+    }
+
+    return VK_SUCCESS;
+}
+
+VkResult VmaAllocator_T::AllocateMemory(
+    const VkMemoryRequirements& vkMemReq,
+    bool requiresDedicatedAllocation,
+    bool prefersDedicatedAllocation,
+    VkBuffer dedicatedBuffer,
+    VkImage dedicatedImage,
+    VkFlags dedicatedBufferImageUsage,
+    const VmaAllocationCreateInfo& createInfo,
+    VmaSuballocationType suballocType,
+    size_t allocationCount,
+    VmaAllocation* pAllocations)
+{
+    memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
+
+    VMA_ASSERT(VmaIsPow2(vkMemReq.alignment));
+
+    if(vkMemReq.size == 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    VmaAllocationCreateInfo createInfoFinal = createInfo;
+    VkResult res = CalcAllocationParams(createInfoFinal, requiresDedicatedAllocation, prefersDedicatedAllocation);
+    if(res != VK_SUCCESS)
+        return res;
+
+    if(createInfoFinal.pool != VK_NULL_HANDLE)
+    {
+        VmaBlockVector& blockVector = createInfoFinal.pool->m_BlockVector;
+        return AllocateMemoryOfType(
+            createInfoFinal.pool,
+            vkMemReq.size,
+            vkMemReq.alignment,
+            prefersDedicatedAllocation,
+            dedicatedBuffer,
+            dedicatedImage,
+            dedicatedBufferImageUsage,
+            createInfoFinal,
+            blockVector.GetMemoryTypeIndex(),
+            suballocType,
+            createInfoFinal.pool->m_DedicatedAllocations,
+            blockVector,
+            allocationCount,
+            pAllocations);
+    }
+    else
+    {
+        // Bit mask of memory Vulkan types acceptable for this allocation.
+        uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
+        uint32_t memTypeIndex = UINT32_MAX;
+        res = FindMemoryTypeIndex(memoryTypeBits, &createInfoFinal, dedicatedBufferImageUsage, &memTypeIndex);
+        // Can't find any single memory type matching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
+        if(res != VK_SUCCESS)
+            return res;
+        do
+        {
+            VmaBlockVector* blockVector = m_pBlockVectors[memTypeIndex];
+            VMA_ASSERT(blockVector && "Trying to use unsupported memory type!");
+            res = AllocateMemoryOfType(
+                VK_NULL_HANDLE,
+                vkMemReq.size,
+                vkMemReq.alignment,
+                requiresDedicatedAllocation || prefersDedicatedAllocation,
+                dedicatedBuffer,
+                dedicatedImage,
+                dedicatedBufferImageUsage,
+                createInfoFinal,
+                memTypeIndex,
+                suballocType,
+                m_DedicatedAllocations[memTypeIndex],
+                *blockVector,
+                allocationCount,
+                pAllocations);
+            // Allocation succeeded
+            if(res == VK_SUCCESS)
+                return VK_SUCCESS;
+
+            // Remove old memTypeIndex from list of possibilities.
+            memoryTypeBits &= ~(1u << memTypeIndex);
+            // Find alternative memTypeIndex.
+            res = FindMemoryTypeIndex(memoryTypeBits, &createInfoFinal, dedicatedBufferImageUsage, &memTypeIndex);
+        } while(res == VK_SUCCESS);
+
+        // No other matching memory type index could be found.
+        // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+    }
+}
+
+void VmaAllocator_T::FreeMemory(
+    size_t allocationCount,
+    const VmaAllocation* pAllocations)
+{
+    VMA_ASSERT(pAllocations);
+
+    for(size_t allocIndex = allocationCount; allocIndex--; )
+    {
+        VmaAllocation allocation = pAllocations[allocIndex];
+
+        if(allocation != VK_NULL_HANDLE)
+        {
+            if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
+            {
+                FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
+            }
+
+            allocation->FreeName(this);
+
+            switch(allocation->GetType())
+            {
+            case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+                {
+                    VmaBlockVector* pBlockVector = VMA_NULL;
+                    VmaPool hPool = allocation->GetParentPool();
+                    if(hPool != VK_NULL_HANDLE)
+                    {
+                        pBlockVector = &hPool->m_BlockVector;
+                    }
+                    else
+                    {
+                        const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
+                        pBlockVector = m_pBlockVectors[memTypeIndex];
+                        VMA_ASSERT(pBlockVector && "Trying to free memory of unsupported type!");
+                    }
+                    pBlockVector->Free(allocation);
+                }
+                break;
+            case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+                FreeDedicatedMemory(allocation);
+                break;
+            default:
+                VMA_ASSERT(0);
+            }
+        }
+    }
+}
+
+void VmaAllocator_T::CalculateStatistics(VmaTotalStatistics* pStats)
+{
+    // Initialize.
+    VmaClearDetailedStatistics(pStats->total);
+    for(uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
+        VmaClearDetailedStatistics(pStats->memoryType[i]);
+    for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
+        VmaClearDetailedStatistics(pStats->memoryHeap[i]);
+
+    // Process default pools.
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
+        if (pBlockVector != VMA_NULL)
+            pBlockVector->AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
+    }
+
+    // Process custom pools.
+    {
+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
+        for(VmaPool pool = m_Pools.Front(); pool != VMA_NULL; pool = m_Pools.GetNext(pool))
+        {
+            VmaBlockVector& blockVector = pool->m_BlockVector;
+            const uint32_t memTypeIndex = blockVector.GetMemoryTypeIndex();
+            blockVector.AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
+            pool->m_DedicatedAllocations.AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
+        }
+    }
+
+    // Process dedicated allocations.
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        m_DedicatedAllocations[memTypeIndex].AddDetailedStatistics(pStats->memoryType[memTypeIndex]);
+    }
+
+    // Sum from memory types to memory heaps.
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        const uint32_t memHeapIndex = m_MemProps.memoryTypes[memTypeIndex].heapIndex;
+        VmaAddDetailedStatistics(pStats->memoryHeap[memHeapIndex], pStats->memoryType[memTypeIndex]);
+    }
+
+    // Sum from memory heaps to total.
+    for(uint32_t memHeapIndex = 0; memHeapIndex < GetMemoryHeapCount(); ++memHeapIndex)
+        VmaAddDetailedStatistics(pStats->total, pStats->memoryHeap[memHeapIndex]);
+
+    VMA_ASSERT(pStats->total.statistics.allocationCount == 0 ||
+        pStats->total.allocationSizeMax >= pStats->total.allocationSizeMin);
+    VMA_ASSERT(pStats->total.unusedRangeCount == 0 ||
+        pStats->total.unusedRangeSizeMax >= pStats->total.unusedRangeSizeMin);
+}
+
+void VmaAllocator_T::GetHeapBudgets(VmaBudget* outBudgets, uint32_t firstHeap, uint32_t heapCount)
+{
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        if(m_Budget.m_OperationsSinceBudgetFetch < 30)
+        {
+            VmaMutexLockRead lockRead(m_Budget.m_BudgetMutex, m_UseMutex);
+            for(uint32_t i = 0; i < heapCount; ++i, ++outBudgets)
+            {
+                const uint32_t heapIndex = firstHeap + i;
+
+                outBudgets->statistics.blockCount = m_Budget.m_BlockCount[heapIndex];
+                outBudgets->statistics.allocationCount = m_Budget.m_AllocationCount[heapIndex];
+                outBudgets->statistics.blockBytes = m_Budget.m_BlockBytes[heapIndex];
+                outBudgets->statistics.allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
+
+                if(m_Budget.m_VulkanUsage[heapIndex] + outBudgets->statistics.blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])
+                {
+                    outBudgets->usage = m_Budget.m_VulkanUsage[heapIndex] +
+                        outBudgets->statistics.blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
+                }
+                else
+                {
+                    outBudgets->usage = 0;
+                }
+
+                // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.
+                outBudgets->budget = VMA_MIN(
+                    m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);
+            }
+        }
+        else
+        {
+            UpdateVulkanBudget(); // Outside of mutex lock
+            GetHeapBudgets(outBudgets, firstHeap, heapCount); // Recursion
+        }
+    }
+    else
+#endif
+    {
+        for(uint32_t i = 0; i < heapCount; ++i, ++outBudgets)
+        {
+            const uint32_t heapIndex = firstHeap + i;
+
+            outBudgets->statistics.blockCount = m_Budget.m_BlockCount[heapIndex];
+            outBudgets->statistics.allocationCount = m_Budget.m_AllocationCount[heapIndex];
+            outBudgets->statistics.blockBytes = m_Budget.m_BlockBytes[heapIndex];
+            outBudgets->statistics.allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
+
+            outBudgets->usage = outBudgets->statistics.blockBytes;
+            outBudgets->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
+        }
+    }
+}
+
+void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
+{
+    pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
+    pAllocationInfo->deviceMemory = hAllocation->GetMemory();
+    pAllocationInfo->offset = hAllocation->GetOffset();
+    pAllocationInfo->size = hAllocation->GetSize();
+    pAllocationInfo->pMappedData = hAllocation->GetMappedData();
+    pAllocationInfo->pUserData = hAllocation->GetUserData();
+    pAllocationInfo->pName = hAllocation->GetName();
+}
+
+VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
+{
+    VMA_DEBUG_LOG("  CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
+
+    VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
+
+    // Protection against uninitialized new structure member. If garbage data are left there, this pointer dereference would crash.
+    if(pCreateInfo->pMemoryAllocateNext)
+    {
+        VMA_ASSERT(((const VkBaseInStructure*)pCreateInfo->pMemoryAllocateNext)->sType != 0);
+    }
+
+    if(newCreateInfo.maxBlockCount == 0)
+    {
+        newCreateInfo.maxBlockCount = SIZE_MAX;
+    }
+    if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    // Memory type index out of range or forbidden.
+    if(pCreateInfo->memoryTypeIndex >= GetMemoryTypeCount() ||
+        ((1u << pCreateInfo->memoryTypeIndex) & m_GlobalMemoryTypeBits) == 0)
+    {
+        return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+    if(newCreateInfo.minAllocationAlignment > 0)
+    {
+        VMA_ASSERT(VmaIsPow2(newCreateInfo.minAllocationAlignment));
+    }
+
+    const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
+
+    *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);
+
+    VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
+    if(res != VK_SUCCESS)
+    {
+        vma_delete(this, *pPool);
+        *pPool = VMA_NULL;
+        return res;
+    }
+
+    // Add to m_Pools.
+    {
+        VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
+        (*pPool)->SetId(m_NextPoolId++);
+        m_Pools.PushBack(*pPool);
+    }
+
+    return VK_SUCCESS;
+}
+
+void VmaAllocator_T::DestroyPool(VmaPool pool)
+{
+    // Remove from m_Pools.
+    {
+        VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
+        m_Pools.Remove(pool);
+    }
+
+    vma_delete(this, pool);
+}
+
+void VmaAllocator_T::GetPoolStatistics(VmaPool pool, VmaStatistics* pPoolStats)
+{
+    VmaClearStatistics(*pPoolStats);
+    pool->m_BlockVector.AddStatistics(*pPoolStats);
+    pool->m_DedicatedAllocations.AddStatistics(*pPoolStats);
+}
+
+void VmaAllocator_T::CalculatePoolStatistics(VmaPool pool, VmaDetailedStatistics* pPoolStats)
+{
+    VmaClearDetailedStatistics(*pPoolStats);
+    pool->m_BlockVector.AddDetailedStatistics(*pPoolStats);
+    pool->m_DedicatedAllocations.AddDetailedStatistics(*pPoolStats);
+}
+
+void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
+{
+    m_CurrentFrameIndex.store(frameIndex);
+
+#if VMA_MEMORY_BUDGET
+    if(m_UseExtMemoryBudget)
+    {
+        UpdateVulkanBudget();
+    }
+#endif // #if VMA_MEMORY_BUDGET
+}
+
+VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
+{
+    return hPool->m_BlockVector.CheckCorruption();
+}
+
+VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
+{
+    VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
+
+    // Process default pools.
+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+    {
+        VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
+        if(pBlockVector != VMA_NULL)
+        {
+            VkResult localRes = pBlockVector->CheckCorruption();
+            switch(localRes)
+            {
+            case VK_ERROR_FEATURE_NOT_PRESENT:
+                break;
+            case VK_SUCCESS:
+                finalRes = VK_SUCCESS;
+                break;
+            default:
+                return localRes;
+            }
+        }
+    }
+
+    // Process custom pools.
+    {
+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
+        for(VmaPool pool = m_Pools.Front(); pool != VMA_NULL; pool = m_Pools.GetNext(pool))
+        {
+            if(((1u << pool->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
+            {
+                VkResult localRes = pool->m_BlockVector.CheckCorruption();
+                switch(localRes)
+                {
+                case VK_ERROR_FEATURE_NOT_PRESENT:
+                    break;
+                case VK_SUCCESS:
+                    finalRes = VK_SUCCESS;
+                    break;
+                default:
+                    return localRes;
+                }
+            }
+        }
+    }
+
+    return finalRes;
+}
+
+VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
+{
+    AtomicTransactionalIncrement<uint32_t> deviceMemoryCountIncrement;
+    const uint64_t prevDeviceMemoryCount = deviceMemoryCountIncrement.Increment(&m_DeviceMemoryCount);
+#if VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT
+    if(prevDeviceMemoryCount >= m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount)
+    {
+        return VK_ERROR_TOO_MANY_OBJECTS;
+    }
+#endif
+
+    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
+
+    // HeapSizeLimit is in effect for this heap.
+    if((m_HeapSizeLimitMask & (1u << heapIndex)) != 0)
+    {
+        const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
+        VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
+        for(;;)
+        {
+            const VkDeviceSize blockBytesAfterAllocation = blockBytes + pAllocateInfo->allocationSize;
+            if(blockBytesAfterAllocation > heapSize)
+            {
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+            if(m_Budget.m_BlockBytes[heapIndex].compare_exchange_strong(blockBytes, blockBytesAfterAllocation))
+            {
+                break;
+            }
+        }
+    }
+    else
+    {
+        m_Budget.m_BlockBytes[heapIndex] += pAllocateInfo->allocationSize;
+    }
+    ++m_Budget.m_BlockCount[heapIndex];
+
+    // VULKAN CALL vkAllocateMemory.
+    VkResult res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
+
+    if(res == VK_SUCCESS)
+    {
+#if VMA_MEMORY_BUDGET
+        ++m_Budget.m_OperationsSinceBudgetFetch;
+#endif
+
+        // Informative callback.
+        if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
+        {
+            (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize, m_DeviceMemoryCallbacks.pUserData);
+        }
+
+        deviceMemoryCountIncrement.Commit();
+    }
+    else
+    {
+        --m_Budget.m_BlockCount[heapIndex];
+        m_Budget.m_BlockBytes[heapIndex] -= pAllocateInfo->allocationSize;
+    }
+
+    return res;
+}
+
+void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
+{
+    // Informative callback.
+    if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
+    {
+        (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size, m_DeviceMemoryCallbacks.pUserData);
+    }
+
+    // VULKAN CALL vkFreeMemory.
+    (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
+
+    const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
+    --m_Budget.m_BlockCount[heapIndex];
+    m_Budget.m_BlockBytes[heapIndex] -= size;
+
+    --m_DeviceMemoryCount;
+}
+
+VkResult VmaAllocator_T::BindVulkanBuffer(
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset,
+    VkBuffer buffer,
+    const void* pNext)
+{
+    if(pNext != VMA_NULL)
+    {
+#if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
+        if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
+            m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL)
+        {
+            VkBindBufferMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR };
+            bindBufferMemoryInfo.pNext = pNext;
+            bindBufferMemoryInfo.buffer = buffer;
+            bindBufferMemoryInfo.memory = memory;
+            bindBufferMemoryInfo.memoryOffset = memoryOffset;
+            return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
+        }
+        else
+#endif // #if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
+        {
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
+        }
+    }
+    else
+    {
+        return (*m_VulkanFunctions.vkBindBufferMemory)(m_hDevice, buffer, memory, memoryOffset);
+    }
+}
+
+VkResult VmaAllocator_T::BindVulkanImage(
+    VkDeviceMemory memory,
+    VkDeviceSize memoryOffset,
+    VkImage image,
+    const void* pNext)
+{
+    if(pNext != VMA_NULL)
+    {
+#if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
+        if((m_UseKhrBindMemory2 || m_VulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)) &&
+            m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL)
+        {
+            VkBindImageMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR };
+            bindBufferMemoryInfo.pNext = pNext;
+            bindBufferMemoryInfo.image = image;
+            bindBufferMemoryInfo.memory = memory;
+            bindBufferMemoryInfo.memoryOffset = memoryOffset;
+            return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
+        }
+        else
+#endif // #if VMA_BIND_MEMORY2
+        {
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
+        }
+    }
+    else
+    {
+        return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
+    }
+}
+
+VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
+{
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+        {
+            VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
+            char *pBytes = VMA_NULL;
+            VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
+            if(res == VK_SUCCESS)
+            {
+                *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
+                hAllocation->BlockAllocMap();
+            }
+            return res;
+        }
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        return hAllocation->DedicatedAllocMap(this, ppData);
+    default:
+        VMA_ASSERT(0);
+        return VK_ERROR_MEMORY_MAP_FAILED;
+    }
+}
+
+void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
+{
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+        {
+            VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
+            hAllocation->BlockAllocUnmap();
+            pBlock->Unmap(this, 1);
+        }
+        break;
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        hAllocation->DedicatedAllocUnmap(this);
+        break;
+    default:
+        VMA_ASSERT(0);
+    }
+}
+
+VkResult VmaAllocator_T::BindBufferMemory(
+    VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer hBuffer,
+    const void* pNext)
+{
+    VkResult res = VK_SUCCESS;
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        res = BindVulkanBuffer(hAllocation->GetMemory(), allocationLocalOffset, hBuffer, pNext);
+        break;
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+    {
+        VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
+        VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block.");
+        res = pBlock->BindBufferMemory(this, hAllocation, allocationLocalOffset, hBuffer, pNext);
+        break;
+    }
+    default:
+        VMA_ASSERT(0);
+    }
+    return res;
+}
+
+VkResult VmaAllocator_T::BindImageMemory(
+    VmaAllocation hAllocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage hImage,
+    const void* pNext)
+{
+    VkResult res = VK_SUCCESS;
+    switch(hAllocation->GetType())
+    {
+    case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+        res = BindVulkanImage(hAllocation->GetMemory(), allocationLocalOffset, hImage, pNext);
+        break;
+    case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+    {
+        VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
+        VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block.");
+        res = pBlock->BindImageMemory(this, hAllocation, allocationLocalOffset, hImage, pNext);
+        break;
+    }
+    default:
+        VMA_ASSERT(0);
+    }
+    return res;
+}
+
+VkResult VmaAllocator_T::FlushOrInvalidateAllocation(
+    VmaAllocation hAllocation,
+    VkDeviceSize offset, VkDeviceSize size,
+    VMA_CACHE_OPERATION op)
+{
+    VkResult res = VK_SUCCESS;
+
+    VkMappedMemoryRange memRange = {};
+    if(GetFlushOrInvalidateRange(hAllocation, offset, size, memRange))
+    {
+        switch(op)
+        {
+        case VMA_CACHE_FLUSH:
+            res = (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
+            break;
+        case VMA_CACHE_INVALIDATE:
+            res = (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
+            break;
+        default:
+            VMA_ASSERT(0);
+        }
+    }
+    // else: Just ignore this call.
+    return res;
+}
+
+VkResult VmaAllocator_T::FlushOrInvalidateAllocations(
+    uint32_t allocationCount,
+    const VmaAllocation* allocations,
+    const VkDeviceSize* offsets, const VkDeviceSize* sizes,
+    VMA_CACHE_OPERATION op)
+{
+    typedef VmaStlAllocator<VkMappedMemoryRange> RangeAllocator;
+    typedef VmaSmallVector<VkMappedMemoryRange, RangeAllocator, 16> RangeVector;
+    RangeVector ranges = RangeVector(RangeAllocator(GetAllocationCallbacks()));
+
+    for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+    {
+        const VmaAllocation alloc = allocations[allocIndex];
+        const VkDeviceSize offset = offsets != VMA_NULL ? offsets[allocIndex] : 0;
+        const VkDeviceSize size = sizes != VMA_NULL ? sizes[allocIndex] : VK_WHOLE_SIZE;
+        VkMappedMemoryRange newRange;
+        if(GetFlushOrInvalidateRange(alloc, offset, size, newRange))
+        {
+            ranges.push_back(newRange);
+        }
+    }
+
+    VkResult res = VK_SUCCESS;
+    if(!ranges.empty())
+    {
+        switch(op)
+        {
+        case VMA_CACHE_FLUSH:
+            res = (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, (uint32_t)ranges.size(), ranges.data());
+            break;
+        case VMA_CACHE_INVALIDATE:
+            res = (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, (uint32_t)ranges.size(), ranges.data());
+            break;
+        default:
+            VMA_ASSERT(0);
+        }
+    }
+    // else: Just ignore this call.
+    return res;
+}
+
+void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
+{
+    VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
+
+    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
+    VmaPool parentPool = allocation->GetParentPool();
+    if(parentPool == VK_NULL_HANDLE)
+    {
+        // Default pool
+        m_DedicatedAllocations[memTypeIndex].Unregister(allocation);
+    }
+    else
+    {
+        // Custom pool
+        parentPool->m_DedicatedAllocations.Unregister(allocation);
+    }
+
+    VkDeviceMemory hMemory = allocation->GetMemory();
+
+    /*
+    There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
+    before vkFreeMemory.
+
+    if(allocation->GetMappedData() != VMA_NULL)
+    {
+        (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
+    }
+    */
+
+    FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
+
+    m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
+    m_AllocationObjectAllocator.Free(allocation);
+
+    VMA_DEBUG_LOG("    Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
+}
+
+uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
+{
+    VkBufferCreateInfo dummyBufCreateInfo;
+    VmaFillGpuDefragmentationBufferCreateInfo(dummyBufCreateInfo);
+
+    uint32_t memoryTypeBits = 0;
+
+    // Create buffer.
+    VkBuffer buf = VK_NULL_HANDLE;
+    VkResult res = (*GetVulkanFunctions().vkCreateBuffer)(
+        m_hDevice, &dummyBufCreateInfo, GetAllocationCallbacks(), &buf);
+    if(res == VK_SUCCESS)
+    {
+        // Query for supported memory types.
+        VkMemoryRequirements memReq;
+        (*GetVulkanFunctions().vkGetBufferMemoryRequirements)(m_hDevice, buf, &memReq);
+        memoryTypeBits = memReq.memoryTypeBits;
+
+        // Destroy buffer.
+        (*GetVulkanFunctions().vkDestroyBuffer)(m_hDevice, buf, GetAllocationCallbacks());
+    }
+
+    return memoryTypeBits;
+}
+
+uint32_t VmaAllocator_T::CalculateGlobalMemoryTypeBits() const
+{
+    // Make sure memory information is already fetched.
+    VMA_ASSERT(GetMemoryTypeCount() > 0);
+
+    uint32_t memoryTypeBits = UINT32_MAX;
+
+    if(!m_UseAmdDeviceCoherentMemory)
+    {
+        // Exclude memory types that have VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD.
+        for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+        {
+            if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY) != 0)
+            {
+                memoryTypeBits &= ~(1u << memTypeIndex);
+            }
+        }
+    }
+
+    return memoryTypeBits;
+}
+
+bool VmaAllocator_T::GetFlushOrInvalidateRange(
+    VmaAllocation allocation,
+    VkDeviceSize offset, VkDeviceSize size,
+    VkMappedMemoryRange& outRange) const
+{
+    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
+    if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
+    {
+        const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
+        const VkDeviceSize allocationSize = allocation->GetSize();
+        VMA_ASSERT(offset <= allocationSize);
+
+        outRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+        outRange.pNext = VMA_NULL;
+        outRange.memory = allocation->GetMemory();
+
+        switch(allocation->GetType())
+        {
+        case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+            outRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
+            if(size == VK_WHOLE_SIZE)
+            {
+                outRange.size = allocationSize - outRange.offset;
+            }
+            else
+            {
+                VMA_ASSERT(offset + size <= allocationSize);
+                outRange.size = VMA_MIN(
+                    VmaAlignUp(size + (offset - outRange.offset), nonCoherentAtomSize),
+                    allocationSize - outRange.offset);
+            }
+            break;
+        case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+        {
+            // 1. Still within this allocation.
+            outRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
+            if(size == VK_WHOLE_SIZE)
+            {
+                size = allocationSize - offset;
+            }
+            else
+            {
+                VMA_ASSERT(offset + size <= allocationSize);
+            }
+            outRange.size = VmaAlignUp(size + (offset - outRange.offset), nonCoherentAtomSize);
+
+            // 2. Adjust to whole block.
+            const VkDeviceSize allocationOffset = allocation->GetOffset();
+            VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
+            const VkDeviceSize blockSize = allocation->GetBlock()->m_pMetadata->GetSize();
+            outRange.offset += allocationOffset;
+            outRange.size = VMA_MIN(outRange.size, blockSize - outRange.offset);
+
+            break;
+        }
+        default:
+            VMA_ASSERT(0);
+        }
+        return true;
+    }
+    return false;
+}
+
+#if VMA_MEMORY_BUDGET
+void VmaAllocator_T::UpdateVulkanBudget()
+{
+    VMA_ASSERT(m_UseExtMemoryBudget);
+
+    VkPhysicalDeviceMemoryProperties2KHR memProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR };
+
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT budgetProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT };
+    VmaPnextChainPushFront(&memProps, &budgetProps);
+
+    GetVulkanFunctions().vkGetPhysicalDeviceMemoryProperties2KHR(m_PhysicalDevice, &memProps);
+
+    {
+        VmaMutexLockWrite lockWrite(m_Budget.m_BudgetMutex, m_UseMutex);
+
+        for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
+        {
+            m_Budget.m_VulkanUsage[heapIndex] = budgetProps.heapUsage[heapIndex];
+            m_Budget.m_VulkanBudget[heapIndex] = budgetProps.heapBudget[heapIndex];
+            m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] = m_Budget.m_BlockBytes[heapIndex].load();
+
+            // Some bugged drivers return the budget incorrectly, e.g. 0 or much bigger than heap size.
+            if(m_Budget.m_VulkanBudget[heapIndex] == 0)
+            {
+                m_Budget.m_VulkanBudget[heapIndex] = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
+            }
+            else if(m_Budget.m_VulkanBudget[heapIndex] > m_MemProps.memoryHeaps[heapIndex].size)
+            {
+                m_Budget.m_VulkanBudget[heapIndex] = m_MemProps.memoryHeaps[heapIndex].size;
+            }
+            if(m_Budget.m_VulkanUsage[heapIndex] == 0 && m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] > 0)
+            {
+                m_Budget.m_VulkanUsage[heapIndex] = m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
+            }
+        }
+        m_Budget.m_OperationsSinceBudgetFetch = 0;
+    }
+}
+#endif // VMA_MEMORY_BUDGET
+
+void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
+{
+    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
+        hAllocation->IsMappingAllowed() &&
+        (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
+    {
+        void* pData = VMA_NULL;
+        VkResult res = Map(hAllocation, &pData);
+        if(res == VK_SUCCESS)
+        {
+            memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
+            FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
+            Unmap(hAllocation);
+        }
+        else
+        {
+            VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
+        }
+    }
+}
+
+uint32_t VmaAllocator_T::GetGpuDefragmentationMemoryTypeBits()
+{
+    uint32_t memoryTypeBits = m_GpuDefragmentationMemoryTypeBits.load();
+    if(memoryTypeBits == UINT32_MAX)
+    {
+        memoryTypeBits = CalculateGpuDefragmentationMemoryTypeBits();
+        m_GpuDefragmentationMemoryTypeBits.store(memoryTypeBits);
+    }
+    return memoryTypeBits;
+}
+
+#if VMA_STATS_STRING_ENABLED
+void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
+{
+    json.WriteString("DefaultPools");
+    json.BeginObject();
+    {
+        for (uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+        {
+            VmaBlockVector* pBlockVector = m_pBlockVectors[memTypeIndex];
+            VmaDedicatedAllocationList& dedicatedAllocList = m_DedicatedAllocations[memTypeIndex];
+            if (pBlockVector != VMA_NULL)
+            {
+                json.BeginString("Type ");
+                json.ContinueString(memTypeIndex);
+                json.EndString();
+                json.BeginObject();
+                {
+                    json.WriteString("PreferredBlockSize");
+                    json.WriteNumber(pBlockVector->GetPreferredBlockSize());
+
+                    json.WriteString("Blocks");
+                    pBlockVector->PrintDetailedMap(json);
+
+                    json.WriteString("DedicatedAllocations");
+                    dedicatedAllocList.BuildStatsString(json);
+                }
+                json.EndObject();
+            }
+        }
+    }
+    json.EndObject();
+
+    json.WriteString("CustomPools");
+    json.BeginObject();
+    {
+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
+        if (!m_Pools.IsEmpty())
+        {
+            for (uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
+            {
+                bool displayType = true;
+                size_t index = 0;
+                for (VmaPool pool = m_Pools.Front(); pool != VMA_NULL; pool = m_Pools.GetNext(pool))
+                {
+                    VmaBlockVector& blockVector = pool->m_BlockVector;
+                    if (blockVector.GetMemoryTypeIndex() == memTypeIndex)
+                    {
+                        if (displayType)
+                        {
+                            json.BeginString("Type ");
+                            json.ContinueString(memTypeIndex);
+                            json.EndString();
+                            json.BeginArray();
+                            displayType = false;
+                        }
+
+                        json.BeginObject();
+                        {
+                            json.WriteString("Name");
+                            json.BeginString();
+                            json.ContinueString_Size(index++);
+                            if (pool->GetName())
+                            {
+                                json.ContinueString(" - ");
+                                json.ContinueString(pool->GetName());
+                            }
+                            json.EndString();
+
+                            json.WriteString("PreferredBlockSize");
+                            json.WriteNumber(blockVector.GetPreferredBlockSize());
+
+                            json.WriteString("Blocks");
+                            blockVector.PrintDetailedMap(json);
+
+                            json.WriteString("DedicatedAllocations");
+                            pool->m_DedicatedAllocations.BuildStatsString(json);
+                        }
+                        json.EndObject();
+                    }
+                }
+
+                if (!displayType)
+                    json.EndArray();
+            }
+        }
+    }
+    json.EndObject();
+}
+#endif // VMA_STATS_STRING_ENABLED
+#endif // _VMA_ALLOCATOR_T_FUNCTIONS
+
+
+#ifndef _VMA_PUBLIC_INTERFACE
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
+    const VmaAllocatorCreateInfo* pCreateInfo,
+    VmaAllocator* pAllocator)
+{
+    VMA_ASSERT(pCreateInfo && pAllocator);
+    VMA_ASSERT(pCreateInfo->vulkanApiVersion == 0 ||
+        (VK_VERSION_MAJOR(pCreateInfo->vulkanApiVersion) == 1 && VK_VERSION_MINOR(pCreateInfo->vulkanApiVersion) <= 3));
+    VMA_DEBUG_LOG("vmaCreateAllocator");
+    *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
+    VkResult result = (*pAllocator)->Init(pCreateInfo);
+    if(result < 0)
+    {
+        vma_delete(pCreateInfo->pAllocationCallbacks, *pAllocator);
+        *pAllocator = VK_NULL_HANDLE;
+    }
+    return result;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
+    VmaAllocator allocator)
+{
+    if(allocator != VK_NULL_HANDLE)
+    {
+        VMA_DEBUG_LOG("vmaDestroyAllocator");
+        VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks; // Have to copy the callbacks when destroying.
+        vma_delete(&allocationCallbacks, allocator);
+    }
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocatorInfo(VmaAllocator allocator, VmaAllocatorInfo* pAllocatorInfo)
+{
+    VMA_ASSERT(allocator && pAllocatorInfo);
+    pAllocatorInfo->instance = allocator->m_hInstance;
+    pAllocatorInfo->physicalDevice = allocator->GetPhysicalDevice();
+    pAllocatorInfo->device = allocator->m_hDevice;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
+    VmaAllocator allocator,
+    const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
+{
+    VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
+    *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
+    VmaAllocator allocator,
+    const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
+{
+    VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
+    *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
+    VmaAllocator allocator,
+    uint32_t memoryTypeIndex,
+    VkMemoryPropertyFlags* pFlags)
+{
+    VMA_ASSERT(allocator && pFlags);
+    VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
+    *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
+    VmaAllocator allocator,
+    uint32_t frameIndex)
+{
+    VMA_ASSERT(allocator);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->SetCurrentFrameIndex(frameIndex);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStatistics(
+    VmaAllocator allocator,
+    VmaTotalStatistics* pStats)
+{
+    VMA_ASSERT(allocator && pStats);
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+    allocator->CalculateStatistics(pStats);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetHeapBudgets(
+    VmaAllocator allocator,
+    VmaBudget* pBudgets)
+{
+    VMA_ASSERT(allocator && pBudgets);
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+    allocator->GetHeapBudgets(pBudgets, 0, allocator->GetMemoryHeapCount());
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
+    VmaAllocator allocator,
+    char** ppStatsString,
+    VkBool32 detailedMap)
+{
+    VMA_ASSERT(allocator && ppStatsString);
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VmaStringBuilder sb(allocator->GetAllocationCallbacks());
+    {
+        VmaBudget budgets[VK_MAX_MEMORY_HEAPS];
+        allocator->GetHeapBudgets(budgets, 0, allocator->GetMemoryHeapCount());
+
+        VmaTotalStatistics stats;
+        allocator->CalculateStatistics(&stats);
+
+        VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
+        json.BeginObject();
+        {
+            json.WriteString("General");
+            json.BeginObject();
+            {
+                const VkPhysicalDeviceProperties& deviceProperties = allocator->m_PhysicalDeviceProperties;
+                const VkPhysicalDeviceMemoryProperties& memoryProperties = allocator->m_MemProps;
+
+                json.WriteString("API");
+                json.WriteString("Vulkan");
+
+                json.WriteString("apiVersion");
+                json.BeginString();
+                json.ContinueString(VK_API_VERSION_MAJOR(deviceProperties.apiVersion));
+                json.ContinueString(".");
+                json.ContinueString(VK_API_VERSION_MINOR(deviceProperties.apiVersion));
+                json.ContinueString(".");
+                json.ContinueString(VK_API_VERSION_PATCH(deviceProperties.apiVersion));
+                json.EndString();
+
+                json.WriteString("GPU");
+                json.WriteString(deviceProperties.deviceName);
+                json.WriteString("deviceType");
+                json.WriteNumber(static_cast<uint32_t>(deviceProperties.deviceType));
+
+                json.WriteString("maxMemoryAllocationCount");
+                json.WriteNumber(deviceProperties.limits.maxMemoryAllocationCount);
+                json.WriteString("bufferImageGranularity");
+                json.WriteNumber(deviceProperties.limits.bufferImageGranularity);
+                json.WriteString("nonCoherentAtomSize");
+                json.WriteNumber(deviceProperties.limits.nonCoherentAtomSize);
+
+                json.WriteString("memoryHeapCount");
+                json.WriteNumber(memoryProperties.memoryHeapCount);
+                json.WriteString("memoryTypeCount");
+                json.WriteNumber(memoryProperties.memoryTypeCount);
+            }
+            json.EndObject();
+        }
+        {
+            json.WriteString("Total");
+            VmaPrintDetailedStatistics(json, stats.total);
+        }
+        {
+            json.WriteString("MemoryInfo");
+            json.BeginObject();
+            {
+                for (uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
+                {
+                    json.BeginString("Heap ");
+                    json.ContinueString(heapIndex);
+                    json.EndString();
+                    json.BeginObject();
+                    {
+                        const VkMemoryHeap& heapInfo = allocator->m_MemProps.memoryHeaps[heapIndex];
+                        json.WriteString("Flags");
+                        json.BeginArray(true);
+                        {
+                            if (heapInfo.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
+                                json.WriteString("DEVICE_LOCAL");
+                        #if VMA_VULKAN_VERSION >= 1001000
+                            if (heapInfo.flags & VK_MEMORY_HEAP_MULTI_INSTANCE_BIT)
+                                json.WriteString("MULTI_INSTANCE");
+                        #endif
+
+                            VkMemoryHeapFlags flags = heapInfo.flags &
+                                ~(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
+                        #if VMA_VULKAN_VERSION >= 1001000
+                                    | VK_MEMORY_HEAP_MULTI_INSTANCE_BIT
+                        #endif
+                                    );
+                            if (flags != 0)
+                                json.WriteNumber(flags);
+                        }
+                        json.EndArray();
+
+                        json.WriteString("Size");
+                        json.WriteNumber(heapInfo.size);
+
+                        json.WriteString("Budget");
+                        json.BeginObject();
+                        {
+                            json.WriteString("BudgetBytes");
+                            json.WriteNumber(budgets[heapIndex].budget);
+                            json.WriteString("UsageBytes");
+                            json.WriteNumber(budgets[heapIndex].usage);
+                        }
+                        json.EndObject();
+
+                        json.WriteString("Stats");
+                        VmaPrintDetailedStatistics(json, stats.memoryHeap[heapIndex]);
+
+                        json.WriteString("MemoryPools");
+                        json.BeginObject();
+                        {
+                            for (uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
+                            {
+                                if (allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
+                                {
+                                    json.BeginString("Type ");
+                                    json.ContinueString(typeIndex);
+                                    json.EndString();
+                                    json.BeginObject();
+                                    {
+                                        json.WriteString("Flags");
+                                        json.BeginArray(true);
+                                        {
+                                            VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
+                                            if (flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
+                                                json.WriteString("DEVICE_LOCAL");
+                                            if (flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+                                                json.WriteString("HOST_VISIBLE");
+                                            if (flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
+                                                json.WriteString("HOST_COHERENT");
+                                            if (flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
+                                                json.WriteString("HOST_CACHED");
+                                            if (flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
+                                                json.WriteString("LAZILY_ALLOCATED");
+                                        #if VMA_VULKAN_VERSION >= 1001000
+                                            if (flags & VK_MEMORY_PROPERTY_PROTECTED_BIT)
+                                                json.WriteString("PROTECTED");
+                                        #endif
+                                        #if VK_AMD_device_coherent_memory
+                                            if (flags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY)
+                                                json.WriteString("DEVICE_COHERENT_AMD");
+                                            if (flags & VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY)
+                                                json.WriteString("DEVICE_UNCACHED_AMD");
+                                        #endif
+
+                                            flags &= ~(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
+                                        #if VMA_VULKAN_VERSION >= 1001000
+                                                | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
+                                        #endif
+                                        #if VK_AMD_device_coherent_memory
+                                                | VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY
+                                                | VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY
+                                        #endif
+                                                | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+                                                | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
+                                                | VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
+                                            if (flags != 0)
+                                                json.WriteNumber(flags);
+                                        }
+                                        json.EndArray();
+
+                                        json.WriteString("Stats");
+                                        VmaPrintDetailedStatistics(json, stats.memoryType[typeIndex]);
+                                    }
+                                    json.EndObject();
+                                }
+                            }
+
+                        }
+                        json.EndObject();
+                    }
+                    json.EndObject();
+                }
+            }
+            json.EndObject();
+        }
+
+        if (detailedMap == VK_TRUE)
+            allocator->PrintDetailedMap(json);
+
+        json.EndObject();
+    }
+
+    *ppStatsString = VmaCreateStringCopy(allocator->GetAllocationCallbacks(), sb.GetData(), sb.GetLength());
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
+    VmaAllocator allocator,
+    char* pStatsString)
+{
+    if(pStatsString != VMA_NULL)
+    {
+        VMA_ASSERT(allocator);
+        VmaFreeString(allocator->GetAllocationCallbacks(), pStatsString);
+    }
+}
+
+#endif // VMA_STATS_STRING_ENABLED
+
+/*
+This function is not protected by any mutex because it just reads immutable data.
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
+    VmaAllocator allocator,
+    uint32_t memoryTypeBits,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    uint32_t* pMemoryTypeIndex)
+{
+    VMA_ASSERT(allocator != VK_NULL_HANDLE);
+    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
+    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
+
+    return allocator->FindMemoryTypeIndex(memoryTypeBits, pAllocationCreateInfo, UINT32_MAX, pMemoryTypeIndex);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
+    VmaAllocator allocator,
+    const VkBufferCreateInfo* pBufferCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    uint32_t* pMemoryTypeIndex)
+{
+    VMA_ASSERT(allocator != VK_NULL_HANDLE);
+    VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
+    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
+    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
+
+    const VkDevice hDev = allocator->m_hDevice;
+    const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
+    VkResult res;
+
+#if VMA_VULKAN_VERSION >= 1003000
+    if(funcs->vkGetDeviceBufferMemoryRequirements)
+    {
+        // Can query straight from VkBufferCreateInfo :)
+        VkDeviceBufferMemoryRequirements devBufMemReq = {VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS};
+        devBufMemReq.pCreateInfo = pBufferCreateInfo;
+
+        VkMemoryRequirements2 memReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
+        (*funcs->vkGetDeviceBufferMemoryRequirements)(hDev, &devBufMemReq, &memReq);
+
+        res = allocator->FindMemoryTypeIndex(
+            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);
+    }
+    else
+#endif // #if VMA_VULKAN_VERSION >= 1003000
+    {
+        // Must create a dummy buffer to query :(
+        VkBuffer hBuffer = VK_NULL_HANDLE;
+        res = funcs->vkCreateBuffer(
+            hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
+        if(res == VK_SUCCESS)
+        {
+            VkMemoryRequirements memReq = {};
+            funcs->vkGetBufferMemoryRequirements(hDev, hBuffer, &memReq);
+
+            res = allocator->FindMemoryTypeIndex(
+                memReq.memoryTypeBits, pAllocationCreateInfo, pBufferCreateInfo->usage, pMemoryTypeIndex);
+
+            funcs->vkDestroyBuffer(
+                hDev, hBuffer, allocator->GetAllocationCallbacks());
+        }
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
+    VmaAllocator allocator,
+    const VkImageCreateInfo* pImageCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    uint32_t* pMemoryTypeIndex)
+{
+    VMA_ASSERT(allocator != VK_NULL_HANDLE);
+    VMA_ASSERT(pImageCreateInfo != VMA_NULL);
+    VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
+    VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
+
+    const VkDevice hDev = allocator->m_hDevice;
+    const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
+    VkResult res;
+
+#if VMA_VULKAN_VERSION >= 1003000
+    if(funcs->vkGetDeviceImageMemoryRequirements)
+    {
+        // Can query straight from VkImageCreateInfo :)
+        VkDeviceImageMemoryRequirements devImgMemReq = {VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS};
+        devImgMemReq.pCreateInfo = pImageCreateInfo;
+        VMA_ASSERT(pImageCreateInfo->tiling != VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT_COPY && (pImageCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT_COPY) == 0 &&
+            "Cannot use this VkImageCreateInfo with vmaFindMemoryTypeIndexForImageInfo as I don't know what to pass as VkDeviceImageMemoryRequirements::planeAspect.");
+
+        VkMemoryRequirements2 memReq = {VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2};
+        (*funcs->vkGetDeviceImageMemoryRequirements)(hDev, &devImgMemReq, &memReq);
+
+        res = allocator->FindMemoryTypeIndex(
+            memReq.memoryRequirements.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);
+    }
+    else
+#endif // #if VMA_VULKAN_VERSION >= 1003000
+    {
+        // Must create a dummy image to query :(
+        VkImage hImage = VK_NULL_HANDLE;
+        res = funcs->vkCreateImage(
+            hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
+        if(res == VK_SUCCESS)
+        {
+            VkMemoryRequirements memReq = {};
+            funcs->vkGetImageMemoryRequirements(hDev, hImage, &memReq);
+
+            res = allocator->FindMemoryTypeIndex(
+                memReq.memoryTypeBits, pAllocationCreateInfo, pImageCreateInfo->usage, pMemoryTypeIndex);
+
+            funcs->vkDestroyImage(
+                hDev, hImage, allocator->GetAllocationCallbacks());
+        }
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
+    VmaAllocator allocator,
+    const VmaPoolCreateInfo* pCreateInfo,
+    VmaPool* pPool)
+{
+    VMA_ASSERT(allocator && pCreateInfo && pPool);
+
+    VMA_DEBUG_LOG("vmaCreatePool");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->CreatePool(pCreateInfo, pPool);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
+    VmaAllocator allocator,
+    VmaPool pool)
+{
+    VMA_ASSERT(allocator);
+
+    if(pool == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaDestroyPool");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->DestroyPool(pool);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStatistics(
+    VmaAllocator allocator,
+    VmaPool pool,
+    VmaStatistics* pPoolStats)
+{
+    VMA_ASSERT(allocator && pool && pPoolStats);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->GetPoolStatistics(pool, pPoolStats);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculatePoolStatistics(
+    VmaAllocator allocator,
+    VmaPool pool,
+    VmaDetailedStatistics* pPoolStats)
+{
+    VMA_ASSERT(allocator && pool && pPoolStats);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->CalculatePoolStatistics(pool, pPoolStats);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
+{
+    VMA_ASSERT(allocator && pool);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VMA_DEBUG_LOG("vmaCheckPoolCorruption");
+
+    return allocator->CheckPoolCorruption(pool);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
+    VmaAllocator allocator,
+    VmaPool pool,
+    const char** ppName)
+{
+    VMA_ASSERT(allocator && pool && ppName);
+
+    VMA_DEBUG_LOG("vmaGetPoolName");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *ppName = pool->GetName();
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
+    VmaAllocator allocator,
+    VmaPool pool,
+    const char* pName)
+{
+    VMA_ASSERT(allocator && pool);
+
+    VMA_DEBUG_LOG("vmaSetPoolName");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    pool->SetName(pName);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
+    VmaAllocator allocator,
+    const VkMemoryRequirements* pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
+
+    VMA_DEBUG_LOG("vmaAllocateMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkResult result = allocator->AllocateMemory(
+        *pVkMemoryRequirements,
+        false, // requiresDedicatedAllocation
+        false, // prefersDedicatedAllocation
+        VK_NULL_HANDLE, // dedicatedBuffer
+        VK_NULL_HANDLE, // dedicatedImage
+        UINT32_MAX, // dedicatedBufferImageUsage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_UNKNOWN,
+        1, // allocationCount
+        pAllocation);
+
+    if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
+    {
+        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
+    VmaAllocator allocator,
+    const VkMemoryRequirements* pVkMemoryRequirements,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    size_t allocationCount,
+    VmaAllocation* pAllocations,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    if(allocationCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocations);
+
+    VMA_DEBUG_LOG("vmaAllocateMemoryPages");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkResult result = allocator->AllocateMemory(
+        *pVkMemoryRequirements,
+        false, // requiresDedicatedAllocation
+        false, // prefersDedicatedAllocation
+        VK_NULL_HANDLE, // dedicatedBuffer
+        VK_NULL_HANDLE, // dedicatedImage
+        UINT32_MAX, // dedicatedBufferImageUsage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_UNKNOWN,
+        allocationCount,
+        pAllocations);
+
+    if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
+    {
+        for(size_t i = 0; i < allocationCount; ++i)
+        {
+            allocator->GetAllocationInfo(pAllocations[i], pAllocationInfo + i);
+        }
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
+    VmaAllocator allocator,
+    VkBuffer buffer,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
+
+    VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkMemoryRequirements vkMemReq = {};
+    bool requiresDedicatedAllocation = false;
+    bool prefersDedicatedAllocation = false;
+    allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
+        requiresDedicatedAllocation,
+        prefersDedicatedAllocation);
+
+    VkResult result = allocator->AllocateMemory(
+        vkMemReq,
+        requiresDedicatedAllocation,
+        prefersDedicatedAllocation,
+        buffer, // dedicatedBuffer
+        VK_NULL_HANDLE, // dedicatedImage
+        UINT32_MAX, // dedicatedBufferImageUsage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_BUFFER,
+        1, // allocationCount
+        pAllocation);
+
+    if(pAllocationInfo && result == VK_SUCCESS)
+    {
+        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
+    VmaAllocator allocator,
+    VkImage image,
+    const VmaAllocationCreateInfo* pCreateInfo,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
+
+    VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    VkMemoryRequirements vkMemReq = {};
+    bool requiresDedicatedAllocation = false;
+    bool prefersDedicatedAllocation  = false;
+    allocator->GetImageMemoryRequirements(image, vkMemReq,
+        requiresDedicatedAllocation, prefersDedicatedAllocation);
+
+    VkResult result = allocator->AllocateMemory(
+        vkMemReq,
+        requiresDedicatedAllocation,
+        prefersDedicatedAllocation,
+        VK_NULL_HANDLE, // dedicatedBuffer
+        image, // dedicatedImage
+        UINT32_MAX, // dedicatedBufferImageUsage
+        *pCreateInfo,
+        VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
+        1, // allocationCount
+        pAllocation);
+
+    if(pAllocationInfo && result == VK_SUCCESS)
+    {
+        allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+    }
+
+    return result;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator);
+
+    if(allocation == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaFreeMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->FreeMemory(
+        1, // allocationCount
+        &allocation);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
+    VmaAllocator allocator,
+    size_t allocationCount,
+    const VmaAllocation* pAllocations)
+{
+    if(allocationCount == 0)
+    {
+        return;
+    }
+
+    VMA_ASSERT(allocator);
+
+    VMA_DEBUG_LOG("vmaFreeMemoryPages");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->FreeMemory(allocationCount, pAllocations);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && allocation && pAllocationInfo);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->GetAllocationInfo(allocation, pAllocationInfo);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    void* pUserData)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocation->SetUserData(allocator, pUserData);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationName(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    const char* VMA_NULLABLE pName)
+{
+    allocation->SetName(allocator, pName);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationMemoryProperties(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    VkMemoryPropertyFlags* VMA_NOT_NULL pFlags)
+{
+    VMA_ASSERT(allocator && allocation && pFlags);
+    const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
+    *pFlags = allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    void** ppData)
+{
+    VMA_ASSERT(allocator && allocation && ppData);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->Map(allocation, ppData);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    allocator->Unmap(allocation);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocation(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkDeviceSize offset,
+    VkDeviceSize size)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_LOG("vmaFlushAllocation");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocation(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkDeviceSize offset,
+    VkDeviceSize size)
+{
+    VMA_ASSERT(allocator && allocation);
+
+    VMA_DEBUG_LOG("vmaInvalidateAllocation");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaFlushAllocations(
+    VmaAllocator allocator,
+    uint32_t allocationCount,
+    const VmaAllocation* allocations,
+    const VkDeviceSize* offsets,
+    const VkDeviceSize* sizes)
+{
+    VMA_ASSERT(allocator);
+
+    if(allocationCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_ASSERT(allocations);
+
+    VMA_DEBUG_LOG("vmaFlushAllocations");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_FLUSH);
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaInvalidateAllocations(
+    VmaAllocator allocator,
+    uint32_t allocationCount,
+    const VmaAllocation* allocations,
+    const VkDeviceSize* offsets,
+    const VkDeviceSize* sizes)
+{
+    VMA_ASSERT(allocator);
+
+    if(allocationCount == 0)
+    {
+        return VK_SUCCESS;
+    }
+
+    VMA_ASSERT(allocations);
+
+    VMA_DEBUG_LOG("vmaInvalidateAllocations");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    const VkResult res = allocator->FlushOrInvalidateAllocations(allocationCount, allocations, offsets, sizes, VMA_CACHE_INVALIDATE);
+
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(
+    VmaAllocator allocator,
+    uint32_t memoryTypeBits)
+{
+    VMA_ASSERT(allocator);
+
+    VMA_DEBUG_LOG("vmaCheckCorruption");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->CheckCorruption(memoryTypeBits);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentation(
+    VmaAllocator allocator,
+    const VmaDefragmentationInfo* pInfo,
+    VmaDefragmentationContext* pContext)
+{
+    VMA_ASSERT(allocator && pInfo && pContext);
+
+    VMA_DEBUG_LOG("vmaBeginDefragmentation");
+
+    if (pInfo->pool != VMA_NULL)
+    {
+        // Check if run on supported algorithms
+        if (pInfo->pool->m_BlockVector.GetAlgorithm() & VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
+            return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *pContext = vma_new(allocator, VmaDefragmentationContext_T)(allocator, *pInfo);
+    return VK_SUCCESS;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaEndDefragmentation(
+    VmaAllocator allocator,
+    VmaDefragmentationContext context,
+    VmaDefragmentationStats* pStats)
+{
+    VMA_ASSERT(allocator && context);
+
+    VMA_DEBUG_LOG("vmaEndDefragmentation");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    if (pStats)
+        context->GetStats(*pStats);
+    vma_delete(allocator, context);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NOT_NULL context,
+    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo)
+{
+    VMA_ASSERT(context && pPassInfo);
+
+    VMA_DEBUG_LOG("vmaBeginDefragmentationPass");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return context->DefragmentPassBegin(*pPassInfo);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaDefragmentationContext VMA_NOT_NULL context,
+    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL pPassInfo)
+{
+    VMA_ASSERT(context && pPassInfo);
+
+    VMA_DEBUG_LOG("vmaEndDefragmentationPass");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return context->DefragmentPassEnd(*pPassInfo);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkBuffer buffer)
+{
+    VMA_ASSERT(allocator && allocation && buffer);
+
+    VMA_DEBUG_LOG("vmaBindBufferMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->BindBufferMemory(allocation, 0, buffer, VMA_NULL);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkBuffer buffer,
+    const void* pNext)
+{
+    VMA_ASSERT(allocator && allocation && buffer);
+
+    VMA_DEBUG_LOG("vmaBindBufferMemory2");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->BindBufferMemory(allocation, allocationLocalOffset, buffer, pNext);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkImage image)
+{
+    VMA_ASSERT(allocator && allocation && image);
+
+    VMA_DEBUG_LOG("vmaBindImageMemory");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    return allocator->BindImageMemory(allocation, 0, image, VMA_NULL);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
+    VmaAllocator allocator,
+    VmaAllocation allocation,
+    VkDeviceSize allocationLocalOffset,
+    VkImage image,
+    const void* pNext)
+{
+    VMA_ASSERT(allocator && allocation && image);
+
+    VMA_DEBUG_LOG("vmaBindImageMemory2");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+        return allocator->BindImageMemory(allocation, allocationLocalOffset, image, pNext);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
+    VmaAllocator allocator,
+    const VkBufferCreateInfo* pBufferCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    VkBuffer* pBuffer,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
+
+    if(pBufferCreateInfo->size == 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY) != 0 &&
+        !allocator->m_UseKhrBufferDeviceAddress)
+    {
+        VMA_ASSERT(0 && "Creating a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT is not valid if VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT was not used.");
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    VMA_DEBUG_LOG("vmaCreateBuffer");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *pBuffer = VK_NULL_HANDLE;
+    *pAllocation = VK_NULL_HANDLE;
+
+    // 1. Create VkBuffer.
+    VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
+        allocator->m_hDevice,
+        pBufferCreateInfo,
+        allocator->GetAllocationCallbacks(),
+        pBuffer);
+    if(res >= 0)
+    {
+        // 2. vkGetBufferMemoryRequirements.
+        VkMemoryRequirements vkMemReq = {};
+        bool requiresDedicatedAllocation = false;
+        bool prefersDedicatedAllocation  = false;
+        allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
+            requiresDedicatedAllocation, prefersDedicatedAllocation);
+
+        // 3. Allocate memory using allocator.
+        res = allocator->AllocateMemory(
+            vkMemReq,
+            requiresDedicatedAllocation,
+            prefersDedicatedAllocation,
+            *pBuffer, // dedicatedBuffer
+            VK_NULL_HANDLE, // dedicatedImage
+            pBufferCreateInfo->usage, // dedicatedBufferImageUsage
+            *pAllocationCreateInfo,
+            VMA_SUBALLOCATION_TYPE_BUFFER,
+            1, // allocationCount
+            pAllocation);
+
+        if(res >= 0)
+        {
+            // 3. Bind buffer with memory.
+            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
+            {
+                res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
+            }
+            if(res >= 0)
+            {
+                // All steps succeeded.
+                #if VMA_STATS_STRING_ENABLED
+                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
+                #endif
+                if(pAllocationInfo != VMA_NULL)
+                {
+                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+                }
+
+                return VK_SUCCESS;
+            }
+            allocator->FreeMemory(
+                1, // allocationCount
+                pAllocation);
+            *pAllocation = VK_NULL_HANDLE;
+            (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
+            *pBuffer = VK_NULL_HANDLE;
+            return res;
+        }
+        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
+        *pBuffer = VK_NULL_HANDLE;
+        return res;
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBufferWithAlignment(
+    VmaAllocator allocator,
+    const VkBufferCreateInfo* pBufferCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    VkDeviceSize minAlignment,
+    VkBuffer* pBuffer,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && VmaIsPow2(minAlignment) && pBuffer && pAllocation);
+
+    if(pBufferCreateInfo->size == 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY) != 0 &&
+        !allocator->m_UseKhrBufferDeviceAddress)
+    {
+        VMA_ASSERT(0 && "Creating a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT is not valid if VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT was not used.");
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    VMA_DEBUG_LOG("vmaCreateBufferWithAlignment");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *pBuffer = VK_NULL_HANDLE;
+    *pAllocation = VK_NULL_HANDLE;
+
+    // 1. Create VkBuffer.
+    VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
+        allocator->m_hDevice,
+        pBufferCreateInfo,
+        allocator->GetAllocationCallbacks(),
+        pBuffer);
+    if(res >= 0)
+    {
+        // 2. vkGetBufferMemoryRequirements.
+        VkMemoryRequirements vkMemReq = {};
+        bool requiresDedicatedAllocation = false;
+        bool prefersDedicatedAllocation  = false;
+        allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
+            requiresDedicatedAllocation, prefersDedicatedAllocation);
+
+        // 2a. Include minAlignment
+        vkMemReq.alignment = VMA_MAX(vkMemReq.alignment, minAlignment);
+
+        // 3. Allocate memory using allocator.
+        res = allocator->AllocateMemory(
+            vkMemReq,
+            requiresDedicatedAllocation,
+            prefersDedicatedAllocation,
+            *pBuffer, // dedicatedBuffer
+            VK_NULL_HANDLE, // dedicatedImage
+            pBufferCreateInfo->usage, // dedicatedBufferImageUsage
+            *pAllocationCreateInfo,
+            VMA_SUBALLOCATION_TYPE_BUFFER,
+            1, // allocationCount
+            pAllocation);
+
+        if(res >= 0)
+        {
+            // 3. Bind buffer with memory.
+            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
+            {
+                res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
+            }
+            if(res >= 0)
+            {
+                // All steps succeeded.
+                #if VMA_STATS_STRING_ENABLED
+                    (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
+                #endif
+                if(pAllocationInfo != VMA_NULL)
+                {
+                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+                }
+
+                return VK_SUCCESS;
+            }
+            allocator->FreeMemory(
+                1, // allocationCount
+                pAllocation);
+            *pAllocation = VK_NULL_HANDLE;
+            (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
+            *pBuffer = VK_NULL_HANDLE;
+            return res;
+        }
+        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
+        *pBuffer = VK_NULL_HANDLE;
+        return res;
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingBuffer(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    const VkBufferCreateInfo* VMA_NOT_NULL pBufferCreateInfo,
+    VkBuffer VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pBuffer)
+{
+    VMA_ASSERT(allocator && pBufferCreateInfo && pBuffer && allocation);
+
+    VMA_DEBUG_LOG("vmaCreateAliasingBuffer");
+
+    *pBuffer = VK_NULL_HANDLE;
+
+    if (pBufferCreateInfo->size == 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    if ((pBufferCreateInfo->usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY) != 0 &&
+        !allocator->m_UseKhrBufferDeviceAddress)
+    {
+        VMA_ASSERT(0 && "Creating a buffer with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT is not valid if VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT was not used.");
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    // 1. Create VkBuffer.
+    VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
+        allocator->m_hDevice,
+        pBufferCreateInfo,
+        allocator->GetAllocationCallbacks(),
+        pBuffer);
+    if (res >= 0)
+    {
+        // 2. Bind buffer with memory.
+        res = allocator->BindBufferMemory(allocation, 0, *pBuffer, VMA_NULL);
+        if (res >= 0)
+        {
+            return VK_SUCCESS;
+        }
+        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
+    }
+    return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
+    VmaAllocator allocator,
+    VkBuffer buffer,
+    VmaAllocation allocation)
+{
+    VMA_ASSERT(allocator);
+
+    if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaDestroyBuffer");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    if(buffer != VK_NULL_HANDLE)
+    {
+        (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
+    }
+
+    if(allocation != VK_NULL_HANDLE)
+    {
+        allocator->FreeMemory(
+            1, // allocationCount
+            &allocation);
+    }
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
+    VmaAllocator allocator,
+    const VkImageCreateInfo* pImageCreateInfo,
+    const VmaAllocationCreateInfo* pAllocationCreateInfo,
+    VkImage* pImage,
+    VmaAllocation* pAllocation,
+    VmaAllocationInfo* pAllocationInfo)
+{
+    VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
+
+    if(pImageCreateInfo->extent.width == 0 ||
+        pImageCreateInfo->extent.height == 0 ||
+        pImageCreateInfo->extent.depth == 0 ||
+        pImageCreateInfo->mipLevels == 0 ||
+        pImageCreateInfo->arrayLayers == 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    VMA_DEBUG_LOG("vmaCreateImage");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    *pImage = VK_NULL_HANDLE;
+    *pAllocation = VK_NULL_HANDLE;
+
+    // 1. Create VkImage.
+    VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
+        allocator->m_hDevice,
+        pImageCreateInfo,
+        allocator->GetAllocationCallbacks(),
+        pImage);
+    if(res >= 0)
+    {
+        VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
+            VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
+            VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
+
+        // 2. Allocate memory using allocator.
+        VkMemoryRequirements vkMemReq = {};
+        bool requiresDedicatedAllocation = false;
+        bool prefersDedicatedAllocation  = false;
+        allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
+            requiresDedicatedAllocation, prefersDedicatedAllocation);
+
+        res = allocator->AllocateMemory(
+            vkMemReq,
+            requiresDedicatedAllocation,
+            prefersDedicatedAllocation,
+            VK_NULL_HANDLE, // dedicatedBuffer
+            *pImage, // dedicatedImage
+            pImageCreateInfo->usage, // dedicatedBufferImageUsage
+            *pAllocationCreateInfo,
+            suballocType,
+            1, // allocationCount
+            pAllocation);
+
+        if(res >= 0)
+        {
+            // 3. Bind image with memory.
+            if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
+            {
+                res = allocator->BindImageMemory(*pAllocation, 0, *pImage, VMA_NULL);
+            }
+            if(res >= 0)
+            {
+                // All steps succeeded.
+                #if VMA_STATS_STRING_ENABLED
+                    (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
+                #endif
+                if(pAllocationInfo != VMA_NULL)
+                {
+                    allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+                }
+
+                return VK_SUCCESS;
+            }
+            allocator->FreeMemory(
+                1, // allocationCount
+                pAllocation);
+            *pAllocation = VK_NULL_HANDLE;
+            (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
+            *pImage = VK_NULL_HANDLE;
+            return res;
+        }
+        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
+        *pImage = VK_NULL_HANDLE;
+        return res;
+    }
+    return res;
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAliasingImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VmaAllocation VMA_NOT_NULL allocation,
+    const VkImageCreateInfo* VMA_NOT_NULL pImageCreateInfo,
+    VkImage VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pImage)
+{
+    VMA_ASSERT(allocator && pImageCreateInfo && pImage && allocation);
+
+    *pImage = VK_NULL_HANDLE;
+
+    VMA_DEBUG_LOG("vmaCreateImage");
+
+    if (pImageCreateInfo->extent.width == 0 ||
+        pImageCreateInfo->extent.height == 0 ||
+        pImageCreateInfo->extent.depth == 0 ||
+        pImageCreateInfo->mipLevels == 0 ||
+        pImageCreateInfo->arrayLayers == 0)
+    {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    // 1. Create VkImage.
+    VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
+        allocator->m_hDevice,
+        pImageCreateInfo,
+        allocator->GetAllocationCallbacks(),
+        pImage);
+    if (res >= 0)
+    {
+        // 2. Bind image with memory.
+        res = allocator->BindImageMemory(allocation, 0, *pImage, VMA_NULL);
+        if (res >= 0)
+        {
+            return VK_SUCCESS;
+        }
+        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
+    }
+    return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
+    VmaAllocator VMA_NOT_NULL allocator,
+    VkImage VMA_NULLABLE_NON_DISPATCHABLE image,
+    VmaAllocation VMA_NULLABLE allocation)
+{
+    VMA_ASSERT(allocator);
+
+    if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
+    {
+        return;
+    }
+
+    VMA_DEBUG_LOG("vmaDestroyImage");
+
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+    if(image != VK_NULL_HANDLE)
+    {
+        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
+    }
+    if(allocation != VK_NULL_HANDLE)
+    {
+        allocator->FreeMemory(
+            1, // allocationCount
+            &allocation);
+    }
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateVirtualBlock(
+    const VmaVirtualBlockCreateInfo* VMA_NOT_NULL pCreateInfo,
+    VmaVirtualBlock VMA_NULLABLE * VMA_NOT_NULL pVirtualBlock)
+{
+    VMA_ASSERT(pCreateInfo && pVirtualBlock);
+    VMA_ASSERT(pCreateInfo->size > 0);
+    VMA_DEBUG_LOG("vmaCreateVirtualBlock");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    *pVirtualBlock = vma_new(pCreateInfo->pAllocationCallbacks, VmaVirtualBlock_T)(*pCreateInfo);
+    VkResult res = (*pVirtualBlock)->Init();
+    if(res < 0)
+    {
+        vma_delete(pCreateInfo->pAllocationCallbacks, *pVirtualBlock);
+        *pVirtualBlock = VK_NULL_HANDLE;
+    }
+    return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyVirtualBlock(VmaVirtualBlock VMA_NULLABLE virtualBlock)
+{
+    if(virtualBlock != VK_NULL_HANDLE)
+    {
+        VMA_DEBUG_LOG("vmaDestroyVirtualBlock");
+        VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+        VkAllocationCallbacks allocationCallbacks = virtualBlock->m_AllocationCallbacks; // Have to copy the callbacks when destroying.
+        vma_delete(&allocationCallbacks, virtualBlock);
+    }
+}
+
+VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaIsVirtualBlockEmpty(VmaVirtualBlock VMA_NOT_NULL virtualBlock)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
+    VMA_DEBUG_LOG("vmaIsVirtualBlockEmpty");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    return virtualBlock->IsEmpty() ? VK_TRUE : VK_FALSE;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualAllocationInfo(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation, VmaVirtualAllocationInfo* VMA_NOT_NULL pVirtualAllocInfo)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pVirtualAllocInfo != VMA_NULL);
+    VMA_DEBUG_LOG("vmaGetVirtualAllocationInfo");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    virtualBlock->GetAllocationInfo(allocation, *pVirtualAllocInfo);
+}
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaVirtualAllocate(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    const VmaVirtualAllocationCreateInfo* VMA_NOT_NULL pCreateInfo, VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE* VMA_NOT_NULL pAllocation,
+    VkDeviceSize* VMA_NULLABLE pOffset)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pCreateInfo != VMA_NULL && pAllocation != VMA_NULL);
+    VMA_DEBUG_LOG("vmaVirtualAllocate");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    return virtualBlock->Allocate(*pCreateInfo, *pAllocation, pOffset);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaVirtualFree(VmaVirtualBlock VMA_NOT_NULL virtualBlock, VmaVirtualAllocation VMA_NULLABLE_NON_DISPATCHABLE allocation)
+{
+    if(allocation != VK_NULL_HANDLE)
+    {
+        VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
+        VMA_DEBUG_LOG("vmaVirtualFree");
+        VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+        virtualBlock->Free(allocation);
+    }
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaClearVirtualBlock(VmaVirtualBlock VMA_NOT_NULL virtualBlock)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
+    VMA_DEBUG_LOG("vmaClearVirtualBlock");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    virtualBlock->Clear();
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaSetVirtualAllocationUserData(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaVirtualAllocation VMA_NOT_NULL_NON_DISPATCHABLE allocation, void* VMA_NULLABLE pUserData)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
+    VMA_DEBUG_LOG("vmaSetVirtualAllocationUserData");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    virtualBlock->SetAllocationUserData(allocation, pUserData);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaGetVirtualBlockStatistics(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaStatistics* VMA_NOT_NULL pStats)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pStats != VMA_NULL);
+    VMA_DEBUG_LOG("vmaGetVirtualBlockStatistics");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    virtualBlock->GetStatistics(*pStats);
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateVirtualBlockStatistics(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    VmaDetailedStatistics* VMA_NOT_NULL pStats)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && pStats != VMA_NULL);
+    VMA_DEBUG_LOG("vmaCalculateVirtualBlockStatistics");
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    virtualBlock->CalculateDetailedStatistics(*pStats);
+}
+
+#if VMA_STATS_STRING_ENABLED
+
+VMA_CALL_PRE void VMA_CALL_POST vmaBuildVirtualBlockStatsString(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    char* VMA_NULLABLE * VMA_NOT_NULL ppStatsString, VkBool32 detailedMap)
+{
+    VMA_ASSERT(virtualBlock != VK_NULL_HANDLE && ppStatsString != VMA_NULL);
+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+    const VkAllocationCallbacks* allocationCallbacks = virtualBlock->GetAllocationCallbacks();
+    VmaStringBuilder sb(allocationCallbacks);
+    virtualBlock->BuildStatsString(detailedMap != VK_FALSE, sb);
+    *ppStatsString = VmaCreateStringCopy(allocationCallbacks, sb.GetData(), sb.GetLength());
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaFreeVirtualBlockStatsString(VmaVirtualBlock VMA_NOT_NULL virtualBlock,
+    char* VMA_NULLABLE pStatsString)
+{
+    if(pStatsString != VMA_NULL)
+    {
+        VMA_ASSERT(virtualBlock != VK_NULL_HANDLE);
+        VMA_DEBUG_GLOBAL_MUTEX_LOCK;
+        VmaFreeString(virtualBlock->GetAllocationCallbacks(), pStatsString);
+    }
+}
+#endif // VMA_STATS_STRING_ENABLED
+#endif // _VMA_PUBLIC_INTERFACE
+#endif // VMA_IMPLEMENTATION
+
+/**
+\page quick_start Quick start
+
+\section quick_start_project_setup Project setup
+
+Vulkan Memory Allocator comes in form of a "stb-style" single header file.
+You don't need to build it as a separate library project.
+You can add this file directly to your project and submit it to code repository next to your other source files.
+
+"Single header" doesn't mean that everything is contained in C/C++ declarations,
+like it tends to be in case of inline functions or C++ templates.
+It means that implementation is bundled with interface in a single file and needs to be extracted using preprocessor macro.
+If you don't do it properly, you will get linker errors.
+
+To do it properly:
+
+-# Include "vk_mem_alloc.h" file in each CPP file where you want to use the library.
+   This includes declarations of all members of the library.
+-# In exactly one CPP file define following macro before this include.
+   It enables also internal definitions.
+
+\code
+#define VMA_IMPLEMENTATION
+#include "vk_mem_alloc.h"
+\endcode
+
+It may be a good idea to create dedicated CPP file just for this purpose.
+
+This library includes header `<vulkan/vulkan.h>`, which in turn
+includes `<windows.h>` on Windows. If you need some specific macros defined
+before including these headers (like `WIN32_LEAN_AND_MEAN` or
+`WINVER` for Windows, `VK_USE_PLATFORM_WIN32_KHR` for Vulkan), you must define
+them before every `#include` of this library.
+
+This library is written in C++, but has C-compatible interface.
+Thus you can include and use vk_mem_alloc.h in C or C++ code, but full
+implementation with `VMA_IMPLEMENTATION` macro must be compiled as C++, NOT as C.
+Some features of C++14 used. STL containers, RTTI, or C++ exceptions are not used.
+
+
+\section quick_start_initialization Initialization
+
+At program startup:
+
+-# Initialize Vulkan to have `VkPhysicalDevice`, `VkDevice` and `VkInstance` object.
+-# Fill VmaAllocatorCreateInfo structure and create #VmaAllocator object by
+   calling vmaCreateAllocator().
+
+Only members `physicalDevice`, `device`, `instance` are required.
+However, you should inform the library which Vulkan version do you use by setting
+VmaAllocatorCreateInfo::vulkanApiVersion and which extensions did you enable
+by setting VmaAllocatorCreateInfo::flags (like #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT for VK_KHR_buffer_device_address).
+Otherwise, VMA would use only features of Vulkan 1.0 core with no extensions.
+
+You may need to configure importing Vulkan functions. There are 3 ways to do this:
+
+-# **If you link with Vulkan static library** (e.g. "vulkan-1.lib" on Windows):
+   - You don't need to do anything.
+   - VMA will use these, as macro `VMA_STATIC_VULKAN_FUNCTIONS` is defined to 1 by default.
+-# **If you want VMA to fetch pointers to Vulkan functions dynamically** using `vkGetInstanceProcAddr`,
+   `vkGetDeviceProcAddr` (this is the option presented in the example below):
+   - Define `VMA_STATIC_VULKAN_FUNCTIONS` to 0, `VMA_DYNAMIC_VULKAN_FUNCTIONS` to 1.
+   - Provide pointers to these two functions via VmaVulkanFunctions::vkGetInstanceProcAddr,
+     VmaVulkanFunctions::vkGetDeviceProcAddr.
+   - The library will fetch pointers to all other functions it needs internally.
+-# **If you fetch pointers to all Vulkan functions in a custom way**, e.g. using some loader like
+   [Volk](https://github.com/zeux/volk):
+   - Define `VMA_STATIC_VULKAN_FUNCTIONS` and `VMA_DYNAMIC_VULKAN_FUNCTIONS` to 0.
+   - Pass these pointers via structure #VmaVulkanFunctions.
+
+\code
+VmaVulkanFunctions vulkanFunctions = {};
+vulkanFunctions.vkGetInstanceProcAddr = &vkGetInstanceProcAddr;
+vulkanFunctions.vkGetDeviceProcAddr = &vkGetDeviceProcAddr;
+
+VmaAllocatorCreateInfo allocatorCreateInfo = {};
+allocatorCreateInfo.vulkanApiVersion = VK_API_VERSION_1_2;
+allocatorCreateInfo.physicalDevice = physicalDevice;
+allocatorCreateInfo.device = device;
+allocatorCreateInfo.instance = instance;
+allocatorCreateInfo.pVulkanFunctions = &vulkanFunctions;
+
+VmaAllocator allocator;
+vmaCreateAllocator(&allocatorCreateInfo, &allocator);
+\endcode
+
+
+\section quick_start_resource_allocation Resource allocation
+
+When you want to create a buffer or image:
+
+-# Fill `VkBufferCreateInfo` / `VkImageCreateInfo` structure.
+-# Fill VmaAllocationCreateInfo structure.
+-# Call vmaCreateBuffer() / vmaCreateImage() to get `VkBuffer`/`VkImage` with memory
+   already allocated and bound to it, plus #VmaAllocation objects that represents its underlying memory.
+
+\code
+VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufferInfo.size = 65536;
+bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.usage = VMA_MEMORY_USAGE_AUTO;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+Don't forget to destroy your objects when no longer needed:
+
+\code
+vmaDestroyBuffer(allocator, buffer, allocation);
+vmaDestroyAllocator(allocator);
+\endcode
+
+
+\page choosing_memory_type Choosing memory type
+
+Physical devices in Vulkan support various combinations of memory heaps and
+types. Help with choosing correct and optimal memory type for your specific
+resource is one of the key features of this library. You can use it by filling
+appropriate members of VmaAllocationCreateInfo structure, as described below.
+You can also combine multiple methods.
+
+-# If you just want to find memory type index that meets your requirements, you
+   can use function: vmaFindMemoryTypeIndexForBufferInfo(),
+   vmaFindMemoryTypeIndexForImageInfo(), vmaFindMemoryTypeIndex().
+-# If you want to allocate a region of device memory without association with any
+   specific image or buffer, you can use function vmaAllocateMemory(). Usage of
+   this function is not recommended and usually not needed.
+   vmaAllocateMemoryPages() function is also provided for creating multiple allocations at once,
+   which may be useful for sparse binding.
+-# If you already have a buffer or an image created, you want to allocate memory
+   for it and then you will bind it yourself, you can use function
+   vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage().
+   For binding you should use functions: vmaBindBufferMemory(), vmaBindImageMemory()
+   or their extended versions: vmaBindBufferMemory2(), vmaBindImageMemory2().
+-# **This is the easiest and recommended way to use this library:**
+   If you want to create a buffer or an image, allocate memory for it and bind
+   them together, all in one call, you can use function vmaCreateBuffer(),
+   vmaCreateImage().
+
+When using 3. or 4., the library internally queries Vulkan for memory types
+supported for that buffer or image (function `vkGetBufferMemoryRequirements()`)
+and uses only one of these types.
+
+If no memory type can be found that meets all the requirements, these functions
+return `VK_ERROR_FEATURE_NOT_PRESENT`.
+
+You can leave VmaAllocationCreateInfo structure completely filled with zeros.
+It means no requirements are specified for memory type.
+It is valid, although not very useful.
+
+\section choosing_memory_type_usage Usage
+
+The easiest way to specify memory requirements is to fill member
+VmaAllocationCreateInfo::usage using one of the values of enum #VmaMemoryUsage.
+It defines high level, common usage types.
+Since version 3 of the library, it is recommended to use #VMA_MEMORY_USAGE_AUTO to let it select best memory type for your resource automatically.
+
+For example, if you want to create a uniform buffer that will be filled using
+transfer only once or infrequently and then used for rendering every frame as a uniform buffer, you can
+do it using following code. The buffer will most likely end up in a memory type with
+`VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT` to be fast to access by the GPU device.
+
+\code
+VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufferInfo.size = 65536;
+bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.usage = VMA_MEMORY_USAGE_AUTO;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+If you have a preference for putting the resource in GPU (device) memory or CPU (host) memory
+on systems with discrete graphics card that have the memories separate, you can use
+#VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE or #VMA_MEMORY_USAGE_AUTO_PREFER_HOST.
+
+When using `VMA_MEMORY_USAGE_AUTO*` while you want to map the allocated memory,
+you also need to specify one of the host access flags:
+#VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
+This will help the library decide about preferred memory type to ensure it has `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`
+so you can map it.
+
+For example, a staging buffer that will be filled via mapped pointer and then
+used as a source of transfer to the buffer decribed previously can be created like this.
+It will likely and up in a memory type that is `HOST_VISIBLE` and `HOST_COHERENT`
+but not `HOST_CACHED` (meaning uncached, write-combined) and not `DEVICE_LOCAL` (meaning system RAM).
+
+\code
+VkBufferCreateInfo stagingBufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+stagingBufferInfo.size = 65536;
+stagingBufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+VmaAllocationCreateInfo stagingAllocInfo = {};
+stagingAllocInfo.usage = VMA_MEMORY_USAGE_AUTO;
+stagingAllocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
+
+VkBuffer stagingBuffer;
+VmaAllocation stagingAllocation;
+vmaCreateBuffer(allocator, &stagingBufferInfo, &stagingAllocInfo, &stagingBuffer, &stagingAllocation, nullptr);
+\endcode
+
+For more examples of creating different kinds of resources, see chapter \ref usage_patterns.
+
+Usage values `VMA_MEMORY_USAGE_AUTO*` are legal to use only when the library knows
+about the resource being created by having `VkBufferCreateInfo` / `VkImageCreateInfo` passed,
+so they work with functions like: vmaCreateBuffer(), vmaCreateImage(), vmaFindMemoryTypeIndexForBufferInfo() etc.
+If you allocate raw memory using function vmaAllocateMemory(), you have to use other means of selecting
+memory type, as decribed below.
+
+\note
+Old usage values (`VMA_MEMORY_USAGE_GPU_ONLY`, `VMA_MEMORY_USAGE_CPU_ONLY`,
+`VMA_MEMORY_USAGE_CPU_TO_GPU`, `VMA_MEMORY_USAGE_GPU_TO_CPU`, `VMA_MEMORY_USAGE_CPU_COPY`)
+are still available and work same way as in previous versions of the library
+for backward compatibility, but they are not recommended.
+
+\section choosing_memory_type_required_preferred_flags Required and preferred flags
+
+You can specify more detailed requirements by filling members
+VmaAllocationCreateInfo::requiredFlags and VmaAllocationCreateInfo::preferredFlags
+with a combination of bits from enum `VkMemoryPropertyFlags`. For example,
+if you want to create a buffer that will be persistently mapped on host (so it
+must be `HOST_VISIBLE`) and preferably will also be `HOST_COHERENT` and `HOST_CACHED`,
+use following code:
+
+\code
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+allocInfo.preferredFlags = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+allocInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+A memory type is chosen that has all the required flags and as many preferred
+flags set as possible.
+
+Value passed in VmaAllocationCreateInfo::usage is internally converted to a set of required and preferred flags,
+plus some extra "magic" (heuristics).
+
+\section choosing_memory_type_explicit_memory_types Explicit memory types
+
+If you inspected memory types available on the physical device and you have
+a preference for memory types that you want to use, you can fill member
+VmaAllocationCreateInfo::memoryTypeBits. It is a bit mask, where each bit set
+means that a memory type with that index is allowed to be used for the
+allocation. Special value 0, just like `UINT32_MAX`, means there are no
+restrictions to memory type index.
+
+Please note that this member is NOT just a memory type index.
+Still you can use it to choose just one, specific memory type.
+For example, if you already determined that your buffer should be created in
+memory type 2, use following code:
+
+\code
+uint32_t memoryTypeIndex = 2;
+
+VmaAllocationCreateInfo allocInfo = {};
+allocInfo.memoryTypeBits = 1u << memoryTypeIndex;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+\endcode
+
+
+\section choosing_memory_type_custom_memory_pools Custom memory pools
+
+If you allocate from custom memory pool, all the ways of specifying memory
+requirements described above are not applicable and the aforementioned members
+of VmaAllocationCreateInfo structure are ignored. Memory type is selected
+explicitly when creating the pool and then used to make all the allocations from
+that pool. For further details, see \ref custom_memory_pools.
+
+\section choosing_memory_type_dedicated_allocations Dedicated allocations
+
+Memory for allocations is reserved out of larger block of `VkDeviceMemory`
+allocated from Vulkan internally. That is the main feature of this whole library.
+You can still request a separate memory block to be created for an allocation,
+just like you would do in a trivial solution without using any allocator.
+In that case, a buffer or image is always bound to that memory at offset 0.
+This is called a "dedicated allocation".
+You can explicitly request it by using flag #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+The library can also internally decide to use dedicated allocation in some cases, e.g.:
+
+- When the size of the allocation is large.
+- When [VK_KHR_dedicated_allocation](@ref vk_khr_dedicated_allocation) extension is enabled
+  and it reports that dedicated allocation is required or recommended for the resource.
+- When allocation of next big memory block fails due to not enough device memory,
+  but allocation with the exact requested size succeeds.
+
+
+\page memory_mapping Memory mapping
+
+To "map memory" in Vulkan means to obtain a CPU pointer to `VkDeviceMemory`,
+to be able to read from it or write to it in CPU code.
+Mapping is possible only of memory allocated from a memory type that has
+`VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` flag.
+Functions `vkMapMemory()`, `vkUnmapMemory()` are designed for this purpose.
+You can use them directly with memory allocated by this library,
+but it is not recommended because of following issue:
+Mapping the same `VkDeviceMemory` block multiple times is illegal - only one mapping at a time is allowed.
+This includes mapping disjoint regions. Mapping is not reference-counted internally by Vulkan.
+Because of this, Vulkan Memory Allocator provides following facilities:
+
+\note If you want to be able to map an allocation, you need to specify one of the flags
+#VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT
+in VmaAllocationCreateInfo::flags. These flags are required for an allocation to be mappable
+when using #VMA_MEMORY_USAGE_AUTO or other `VMA_MEMORY_USAGE_AUTO*` enum values.
+For other usage values they are ignored and every such allocation made in `HOST_VISIBLE` memory type is mappable,
+but they can still be used for consistency.
+
+\section memory_mapping_mapping_functions Mapping functions
+
+The library provides following functions for mapping of a specific #VmaAllocation: vmaMapMemory(), vmaUnmapMemory().
+They are safer and more convenient to use than standard Vulkan functions.
+You can map an allocation multiple times simultaneously - mapping is reference-counted internally.
+You can also map different allocations simultaneously regardless of whether they use the same `VkDeviceMemory` block.
+The way it is implemented is that the library always maps entire memory block, not just region of the allocation.
+For further details, see description of vmaMapMemory() function.
+Example:
+
+\code
+// Having these objects initialized:
+struct ConstantBuffer
+{
+    ...
+};
+ConstantBuffer constantBufferData = ...
+
+VmaAllocator allocator = ...
+VkBuffer constantBuffer = ...
+VmaAllocation constantBufferAllocation = ...
+
+// You can map and fill your buffer using following code:
+
+void* mappedData;
+vmaMapMemory(allocator, constantBufferAllocation, &mappedData);
+memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));
+vmaUnmapMemory(allocator, constantBufferAllocation);
+\endcode
+
+When mapping, you may see a warning from Vulkan validation layer similar to this one:
+
+<i>Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.</i>
+
+It happens because the library maps entire `VkDeviceMemory` block, where different
+types of images and buffers may end up together, especially on GPUs with unified memory like Intel.
+You can safely ignore it if you are sure you access only memory of the intended
+object that you wanted to map.
+
+
+\section memory_mapping_persistently_mapped_memory Persistently mapped memory
+
+Kepping your memory persistently mapped is generally OK in Vulkan.
+You don't need to unmap it before using its data on the GPU.
+The library provides a special feature designed for that:
+Allocations made with #VMA_ALLOCATION_CREATE_MAPPED_BIT flag set in
+VmaAllocationCreateInfo::flags stay mapped all the time,
+so you can just access CPU pointer to it any time
+without a need to call any "map" or "unmap" function.
+Example:
+
+\code
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = sizeof(ConstantBuffer);
+bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
+    VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
+// Buffer is already mapped. You can access its memory.
+memcpy(allocInfo.pMappedData, &constantBufferData, sizeof(constantBufferData));
+\endcode
+
+\note #VMA_ALLOCATION_CREATE_MAPPED_BIT by itself doesn't guarantee that the allocation will end up
+in a mappable memory type.
+For this, you need to also specify #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT or
+#VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
+#VMA_ALLOCATION_CREATE_MAPPED_BIT only guarantees that if the memory is `HOST_VISIBLE`, the allocation will be mapped on creation.
+For an example of how to make use of this fact, see section \ref usage_patterns_advanced_data_uploading.
+
+\section memory_mapping_cache_control Cache flush and invalidate
+
+Memory in Vulkan doesn't need to be unmapped before using it on GPU,
+but unless a memory types has `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT` flag set,
+you need to manually **invalidate** cache before reading of mapped pointer
+and **flush** cache after writing to mapped pointer.
+Map/unmap operations don't do that automatically.
+Vulkan provides following functions for this purpose `vkFlushMappedMemoryRanges()`,
+`vkInvalidateMappedMemoryRanges()`, but this library provides more convenient
+functions that refer to given allocation object: vmaFlushAllocation(),
+vmaInvalidateAllocation(),
+or multiple objects at once: vmaFlushAllocations(), vmaInvalidateAllocations().
+
+Regions of memory specified for flush/invalidate must be aligned to
+`VkPhysicalDeviceLimits::nonCoherentAtomSize`. This is automatically ensured by the library.
+In any memory type that is `HOST_VISIBLE` but not `HOST_COHERENT`, all allocations
+within blocks are aligned to this value, so their offsets are always multiply of
+`nonCoherentAtomSize` and two different allocations never share same "line" of this size.
+
+Also, Windows drivers from all 3 PC GPU vendors (AMD, Intel, NVIDIA)
+currently provide `HOST_COHERENT` flag on all memory types that are
+`HOST_VISIBLE`, so on PC you may not need to bother.
+
+
+\page staying_within_budget Staying within budget
+
+When developing a graphics-intensive game or program, it is important to avoid allocating
+more GPU memory than it is physically available. When the memory is over-committed,
+various bad things can happen, depending on the specific GPU, graphics driver, and
+operating system:
+
+- It may just work without any problems.
+- The application may slow down because some memory blocks are moved to system RAM
+  and the GPU has to access them through PCI Express bus.
+- A new allocation may take very long time to complete, even few seconds, and possibly
+  freeze entire system.
+- The new allocation may fail with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+- It may even result in GPU crash (TDR), observed as `VK_ERROR_DEVICE_LOST`
+  returned somewhere later.
+
+\section staying_within_budget_querying_for_budget Querying for budget
+
+To query for current memory usage and available budget, use function vmaGetHeapBudgets().
+Returned structure #VmaBudget contains quantities expressed in bytes, per Vulkan memory heap.
+
+Please note that this function returns different information and works faster than
+vmaCalculateStatistics(). vmaGetHeapBudgets() can be called every frame or even before every
+allocation, while vmaCalculateStatistics() is intended to be used rarely,
+only to obtain statistical information, e.g. for debugging purposes.
+
+It is recommended to use <b>VK_EXT_memory_budget</b> device extension to obtain information
+about the budget from Vulkan device. VMA is able to use this extension automatically.
+When not enabled, the allocator behaves same way, but then it estimates current usage
+and available budget based on its internal information and Vulkan memory heap sizes,
+which may be less precise. In order to use this extension:
+
+1. Make sure extensions VK_EXT_memory_budget and VK_KHR_get_physical_device_properties2
+   required by it are available and enable them. Please note that the first is a device
+   extension and the second is instance extension!
+2. Use flag #VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT when creating #VmaAllocator object.
+3. Make sure to call vmaSetCurrentFrameIndex() every frame. Budget is queried from
+   Vulkan inside of it to avoid overhead of querying it with every allocation.
+
+\section staying_within_budget_controlling_memory_usage Controlling memory usage
+
+There are many ways in which you can try to stay within the budget.
+
+First, when making new allocation requires allocating a new memory block, the library
+tries not to exceed the budget automatically. If a block with default recommended size
+(e.g. 256 MB) would go over budget, a smaller block is allocated, possibly even
+dedicated memory for just this resource.
+
+If the size of the requested resource plus current memory usage is more than the
+budget, by default the library still tries to create it, leaving it to the Vulkan
+implementation whether the allocation succeeds or fails. You can change this behavior
+by using #VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT flag. With it, the allocation is
+not made if it would exceed the budget or if the budget is already exceeded.
+VMA then tries to make the allocation from the next eligible Vulkan memory type.
+The all of them fail, the call then fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+Example usage pattern may be to pass the #VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT flag
+when creating resources that are not essential for the application (e.g. the texture
+of a specific object) and not to pass it when creating critically important resources
+(e.g. render targets).
+
+On AMD graphics cards there is a custom vendor extension available: <b>VK_AMD_memory_overallocation_behavior</b>
+that allows to control the behavior of the Vulkan implementation in out-of-memory cases -
+whether it should fail with an error code or still allow the allocation.
+Usage of this extension involves only passing extra structure on Vulkan device creation,
+so it is out of scope of this library.
+
+Finally, you can also use #VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT flag to make sure
+a new allocation is created only when it fits inside one of the existing memory blocks.
+If it would require to allocate a new block, if fails instead with `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+This also ensures that the function call is very fast because it never goes to Vulkan
+to obtain a new block.
+
+\note Creating \ref custom_memory_pools with VmaPoolCreateInfo::minBlockCount
+set to more than 0 will currently try to allocate memory blocks without checking whether they
+fit within budget.
+
+
+\page resource_aliasing Resource aliasing (overlap)
+
+New explicit graphics APIs (Vulkan and Direct3D 12), thanks to manual memory
+management, give an opportunity to alias (overlap) multiple resources in the
+same region of memory - a feature not available in the old APIs (Direct3D 11, OpenGL).
+It can be useful to save video memory, but it must be used with caution.
+
+For example, if you know the flow of your whole render frame in advance, you
+are going to use some intermediate textures or buffers only during a small range of render passes,
+and you know these ranges don't overlap in time, you can bind these resources to
+the same place in memory, even if they have completely different parameters (width, height, format etc.).
+
+![Resource aliasing (overlap)](../gfx/Aliasing.png)
+
+Such scenario is possible using VMA, but you need to create your images manually.
+Then you need to calculate parameters of an allocation to be made using formula:
+
+- allocation size = max(size of each image)
+- allocation alignment = max(alignment of each image)
+- allocation memoryTypeBits = bitwise AND(memoryTypeBits of each image)
+
+Following example shows two different images bound to the same place in memory,
+allocated to fit largest of them.
+
+\code
+// A 512x512 texture to be sampled.
+VkImageCreateInfo img1CreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+img1CreateInfo.imageType = VK_IMAGE_TYPE_2D;
+img1CreateInfo.extent.width = 512;
+img1CreateInfo.extent.height = 512;
+img1CreateInfo.extent.depth = 1;
+img1CreateInfo.mipLevels = 10;
+img1CreateInfo.arrayLayers = 1;
+img1CreateInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
+img1CreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+img1CreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+img1CreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+img1CreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+
+// A full screen texture to be used as color attachment.
+VkImageCreateInfo img2CreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+img2CreateInfo.imageType = VK_IMAGE_TYPE_2D;
+img2CreateInfo.extent.width = 1920;
+img2CreateInfo.extent.height = 1080;
+img2CreateInfo.extent.depth = 1;
+img2CreateInfo.mipLevels = 1;
+img2CreateInfo.arrayLayers = 1;
+img2CreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
+img2CreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+img2CreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+img2CreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+img2CreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+
+VkImage img1;
+res = vkCreateImage(device, &img1CreateInfo, nullptr, &img1);
+VkImage img2;
+res = vkCreateImage(device, &img2CreateInfo, nullptr, &img2);
+
+VkMemoryRequirements img1MemReq;
+vkGetImageMemoryRequirements(device, img1, &img1MemReq);
+VkMemoryRequirements img2MemReq;
+vkGetImageMemoryRequirements(device, img2, &img2MemReq);
+
+VkMemoryRequirements finalMemReq = {};
+finalMemReq.size = std::max(img1MemReq.size, img2MemReq.size);
+finalMemReq.alignment = std::max(img1MemReq.alignment, img2MemReq.alignment);
+finalMemReq.memoryTypeBits = img1MemReq.memoryTypeBits & img2MemReq.memoryTypeBits;
+// Validate if(finalMemReq.memoryTypeBits != 0)
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+
+VmaAllocation alloc;
+res = vmaAllocateMemory(allocator, &finalMemReq, &allocCreateInfo, &alloc, nullptr);
+
+res = vmaBindImageMemory(allocator, alloc, img1);
+res = vmaBindImageMemory(allocator, alloc, img2);
+
+// You can use img1, img2 here, but not at the same time!
+
+vmaFreeMemory(allocator, alloc);
+vkDestroyImage(allocator, img2, nullptr);
+vkDestroyImage(allocator, img1, nullptr);
+\endcode
+
+Remember that using resources that alias in memory requires proper synchronization.
+You need to issue a memory barrier to make sure commands that use `img1` and `img2`
+don't overlap on GPU timeline.
+You also need to treat a resource after aliasing as uninitialized - containing garbage data.
+For example, if you use `img1` and then want to use `img2`, you need to issue
+an image memory barrier for `img2` with `oldLayout` = `VK_IMAGE_LAYOUT_UNDEFINED`.
+
+Additional considerations:
+
+- Vulkan also allows to interpret contents of memory between aliasing resources consistently in some cases.
+See chapter 11.8. "Memory Aliasing" of Vulkan specification or `VK_IMAGE_CREATE_ALIAS_BIT` flag.
+- You can create more complex layout where different images and buffers are bound
+at different offsets inside one large allocation. For example, one can imagine
+a big texture used in some render passes, aliasing with a set of many small buffers
+used between in some further passes. To bind a resource at non-zero offset in an allocation,
+use vmaBindBufferMemory2() / vmaBindImageMemory2().
+- Before allocating memory for the resources you want to alias, check `memoryTypeBits`
+returned in memory requirements of each resource to make sure the bits overlap.
+Some GPUs may expose multiple memory types suitable e.g. only for buffers or
+images with `COLOR_ATTACHMENT` usage, so the sets of memory types supported by your
+resources may be disjoint. Aliasing them is not possible in that case.
+
+
+\page custom_memory_pools Custom memory pools
+
+A memory pool contains a number of `VkDeviceMemory` blocks.
+The library automatically creates and manages default pool for each memory type available on the device.
+Default memory pool automatically grows in size.
+Size of allocated blocks is also variable and managed automatically.
+
+You can create custom pool and allocate memory out of it.
+It can be useful if you want to:
+
+- Keep certain kind of allocations separate from others.
+- Enforce particular, fixed size of Vulkan memory blocks.
+- Limit maximum amount of Vulkan memory allocated for that pool.
+- Reserve minimum or fixed amount of Vulkan memory always preallocated for that pool.
+- Use extra parameters for a set of your allocations that are available in #VmaPoolCreateInfo but not in
+  #VmaAllocationCreateInfo - e.g., custom minimum alignment, custom `pNext` chain.
+- Perform defragmentation on a specific subset of your allocations.
+
+To use custom memory pools:
+
+-# Fill VmaPoolCreateInfo structure.
+-# Call vmaCreatePool() to obtain #VmaPool handle.
+-# When making an allocation, set VmaAllocationCreateInfo::pool to this handle.
+   You don't need to specify any other parameters of this structure, like `usage`.
+
+Example:
+
+\code
+// Find memoryTypeIndex for the pool.
+VkBufferCreateInfo sampleBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+sampleBufCreateInfo.size = 0x10000; // Doesn't matter.
+sampleBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo sampleAllocCreateInfo = {};
+sampleAllocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+
+uint32_t memTypeIndex;
+VkResult res = vmaFindMemoryTypeIndexForBufferInfo(allocator,
+    &sampleBufCreateInfo, &sampleAllocCreateInfo, &memTypeIndex);
+// Check res...
+
+// Create a pool that can have at most 2 blocks, 128 MiB each.
+VmaPoolCreateInfo poolCreateInfo = {};
+poolCreateInfo.memoryTypeIndex = memTypeIndex;
+poolCreateInfo.blockSize = 128ull * 1024 * 1024;
+poolCreateInfo.maxBlockCount = 2;
+
+VmaPool pool;
+res = vmaCreatePool(allocator, &poolCreateInfo, &pool);
+// Check res...
+
+// Allocate a buffer out of it.
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = 1024;
+bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.pool = pool;
+
+VkBuffer buf;
+VmaAllocation alloc;
+res = vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, nullptr);
+// Check res...
+\endcode
+
+You have to free all allocations made from this pool before destroying it.
+
+\code
+vmaDestroyBuffer(allocator, buf, alloc);
+vmaDestroyPool(allocator, pool);
+\endcode
+
+New versions of this library support creating dedicated allocations in custom pools.
+It is supported only when VmaPoolCreateInfo::blockSize = 0.
+To use this feature, set VmaAllocationCreateInfo::pool to the pointer to your custom pool and
+VmaAllocationCreateInfo::flags to #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+
+\note Excessive use of custom pools is a common mistake when using this library.
+Custom pools may be useful for special purposes - when you want to
+keep certain type of resources separate e.g. to reserve minimum amount of memory
+for them or limit maximum amount of memory they can occupy. For most
+resources this is not needed and so it is not recommended to create #VmaPool
+objects and allocations out of them. Allocating from the default pool is sufficient.
+
+
+\section custom_memory_pools_MemTypeIndex Choosing memory type index
+
+When creating a pool, you must explicitly specify memory type index.
+To find the one suitable for your buffers or images, you can use helper functions
+vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo().
+You need to provide structures with example parameters of buffers or images
+that you are going to create in that pool.
+
+\code
+VkBufferCreateInfo exampleBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+exampleBufCreateInfo.size = 1024; // Doesn't matter
+exampleBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+
+uint32_t memTypeIndex;
+vmaFindMemoryTypeIndexForBufferInfo(allocator, &exampleBufCreateInfo, &allocCreateInfo, &memTypeIndex);
+
+VmaPoolCreateInfo poolCreateInfo = {};
+poolCreateInfo.memoryTypeIndex = memTypeIndex;
+// ...
+\endcode
+
+When creating buffers/images allocated in that pool, provide following parameters:
+
+- `VkBufferCreateInfo`: Prefer to pass same parameters as above.
+  Otherwise you risk creating resources in a memory type that is not suitable for them, which may result in undefined behavior.
+  Using different `VK_BUFFER_USAGE_` flags may work, but you shouldn't create images in a pool intended for buffers
+  or the other way around.
+- VmaAllocationCreateInfo: You don't need to pass same parameters. Fill only `pool` member.
+  Other members are ignored anyway.
+
+\section linear_algorithm Linear allocation algorithm
+
+Each Vulkan memory block managed by this library has accompanying metadata that
+keeps track of used and unused regions. By default, the metadata structure and
+algorithm tries to find best place for new allocations among free regions to
+optimize memory usage. This way you can allocate and free objects in any order.
+
+![Default allocation algorithm](../gfx/Linear_allocator_1_algo_default.png)
+
+Sometimes there is a need to use simpler, linear allocation algorithm. You can
+create custom pool that uses such algorithm by adding flag
+#VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT to VmaPoolCreateInfo::flags while creating
+#VmaPool object. Then an alternative metadata management is used. It always
+creates new allocations after last one and doesn't reuse free regions after
+allocations freed in the middle. It results in better allocation performance and
+less memory consumed by metadata.
+
+![Linear allocation algorithm](../gfx/Linear_allocator_2_algo_linear.png)
+
+With this one flag, you can create a custom pool that can be used in many ways:
+free-at-once, stack, double stack, and ring buffer. See below for details.
+You don't need to specify explicitly which of these options you are going to use - it is detected automatically.
+
+\subsection linear_algorithm_free_at_once Free-at-once
+
+In a pool that uses linear algorithm, you still need to free all the allocations
+individually, e.g. by using vmaFreeMemory() or vmaDestroyBuffer(). You can free
+them in any order. New allocations are always made after last one - free space
+in the middle is not reused. However, when you release all the allocation and
+the pool becomes empty, allocation starts from the beginning again. This way you
+can use linear algorithm to speed up creation of allocations that you are going
+to release all at once.
+
+![Free-at-once](../gfx/Linear_allocator_3_free_at_once.png)
+
+This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount
+value that allows multiple memory blocks.
+
+\subsection linear_algorithm_stack Stack
+
+When you free an allocation that was created last, its space can be reused.
+Thanks to this, if you always release allocations in the order opposite to their
+creation (LIFO - Last In First Out), you can achieve behavior of a stack.
+
+![Stack](../gfx/Linear_allocator_4_stack.png)
+
+This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount
+value that allows multiple memory blocks.
+
+\subsection linear_algorithm_double_stack Double stack
+
+The space reserved by a custom pool with linear algorithm may be used by two
+stacks:
+
+- First, default one, growing up from offset 0.
+- Second, "upper" one, growing down from the end towards lower offsets.
+
+To make allocation from the upper stack, add flag #VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
+to VmaAllocationCreateInfo::flags.
+
+![Double stack](../gfx/Linear_allocator_7_double_stack.png)
+
+Double stack is available only in pools with one memory block -
+VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.
+
+When the two stacks' ends meet so there is not enough space between them for a
+new allocation, such allocation fails with usual
+`VK_ERROR_OUT_OF_DEVICE_MEMORY` error.
+
+\subsection linear_algorithm_ring_buffer Ring buffer
+
+When you free some allocations from the beginning and there is not enough free space
+for a new one at the end of a pool, allocator's "cursor" wraps around to the
+beginning and starts allocation there. Thanks to this, if you always release
+allocations in the same order as you created them (FIFO - First In First Out),
+you can achieve behavior of a ring buffer / queue.
+
+![Ring buffer](../gfx/Linear_allocator_5_ring_buffer.png)
+
+Ring buffer is available only in pools with one memory block -
+VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.
+
+\note \ref defragmentation is not supported in custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT.
+
+
+\page defragmentation Defragmentation
+
+Interleaved allocations and deallocations of many objects of varying size can
+cause fragmentation over time, which can lead to a situation where the library is unable
+to find a continuous range of free memory for a new allocation despite there is
+enough free space, just scattered across many small free ranges between existing
+allocations.
+
+To mitigate this problem, you can use defragmentation feature.
+It doesn't happen automatically though and needs your cooperation,
+because VMA is a low level library that only allocates memory.
+It cannot recreate buffers and images in a new place as it doesn't remember the contents of `VkBufferCreateInfo` / `VkImageCreateInfo` structures.
+It cannot copy their contents as it doesn't record any commands to a command buffer.
+
+Example:
+
+\code
+VmaDefragmentationInfo defragInfo = {};
+defragInfo.pool = myPool;
+defragInfo.flags = VMA_DEFRAGMENTATION_FLAG_ALGORITHM_FAST_BIT;
+
+VmaDefragmentationContext defragCtx;
+VkResult res = vmaBeginDefragmentation(allocator, &defragInfo, &defragCtx);
+// Check res...
+
+for(;;)
+{
+    VmaDefragmentationPassMoveInfo pass;
+    res = vmaBeginDefragmentationPass(allocator, defragCtx, &pass);
+    if(res == VK_SUCCESS)
+        break;
+    else if(res != VK_INCOMPLETE)
+        // Handle error...
+
+    for(uint32_t i = 0; i < pass.moveCount; ++i)
+    {
+        // Inspect pass.pMoves[i].srcAllocation, identify what buffer/image it represents.
+        VmaAllocationInfo allocInfo;
+        vmaGetAllocationInfo(allocator, pMoves[i].srcAllocation, &allocInfo);
+        MyEngineResourceData* resData = (MyEngineResourceData*)allocInfo.pUserData;
+            
+        // Recreate and bind this buffer/image at: pass.pMoves[i].dstMemory, pass.pMoves[i].dstOffset.
+        VkImageCreateInfo imgCreateInfo = ...
+        VkImage newImg;
+        res = vkCreateImage(device, &imgCreateInfo, nullptr, &newImg);
+        // Check res...
+        res = vmaBindImageMemory(allocator, pMoves[i].dstTmpAllocation, newImg);
+        // Check res...
+
+        // Issue a vkCmdCopyBuffer/vkCmdCopyImage to copy its content to the new place.
+        vkCmdCopyImage(cmdBuf, resData->img, ..., newImg, ...);
+    }
+        
+    // Make sure the copy commands finished executing.
+    vkWaitForFences(...);
+
+    // Destroy old buffers/images bound with pass.pMoves[i].srcAllocation.
+    for(uint32_t i = 0; i < pass.moveCount; ++i)
+    {
+        // ...
+        vkDestroyImage(device, resData->img, nullptr);
+    }
+
+    // Update appropriate descriptors to point to the new places...
+        
+    res = vmaEndDefragmentationPass(allocator, defragCtx, &pass);
+    if(res == VK_SUCCESS)
+        break;
+    else if(res != VK_INCOMPLETE)
+        // Handle error...
+}
+
+vmaEndDefragmentation(allocator, defragCtx, nullptr);
+\endcode
+
+Although functions like vmaCreateBuffer(), vmaCreateImage(), vmaDestroyBuffer(), vmaDestroyImage()
+create/destroy an allocation and a buffer/image at once, these are just a shortcut for
+creating the resource, allocating memory, and binding them together.
+Defragmentation works on memory allocations only. You must handle the rest manually.
+Defragmentation is an iterative process that should repreat "passes" as long as related functions
+return `VK_INCOMPLETE` not `VK_SUCCESS`.
+In each pass:
+
+1. vmaBeginDefragmentationPass() function call:
+   - Calculates and returns the list of allocations to be moved in this pass.
+     Note this can be a time-consuming process.
+   - Reserves destination memory for them by creating temporary destination allocations
+     that you can query for their `VkDeviceMemory` + offset using vmaGetAllocationInfo().
+2. Inside the pass, **you should**:
+   - Inspect the returned list of allocations to be moved.
+   - Create new buffers/images and bind them at the returned destination temporary allocations.
+   - Copy data from source to destination resources if necessary.
+   - Destroy the source buffers/images, but NOT their allocations.
+3. vmaEndDefragmentationPass() function call:
+   - Frees the source memory reserved for the allocations that are moved.
+   - Modifies source #VmaAllocation objects that are moved to point to the destination reserved memory.
+   - Frees `VkDeviceMemory` blocks that became empty.
+
+Unlike in previous iterations of the defragmentation API, there is no list of "movable" allocations passed as a parameter.
+Defragmentation algorithm tries to move all suitable allocations.
+You can, however, refuse to move some of them inside a defragmentation pass, by setting
+`pass.pMoves[i].operation` to #VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
+This is not recommended and may result in suboptimal packing of the allocations after defragmentation.
+If you cannot ensure any allocation can be moved, it is better to keep movable allocations separate in a custom pool.
+
+Inside a pass, for each allocation that should be moved:
+
+- You should copy its data from the source to the destination place by calling e.g. `vkCmdCopyBuffer()`, `vkCmdCopyImage()`.
+  - You need to make sure these commands finished executing before destroying the source buffers/images and before calling vmaEndDefragmentationPass().
+- If a resource doesn't contain any meaningful data, e.g. it is a transient color attachment image to be cleared,
+  filled, and used temporarily in each rendering frame, you can just recreate this image
+  without copying its data.
+- If the resource is in `HOST_VISIBLE` and `HOST_CACHED` memory, you can copy its data on the CPU
+  using `memcpy()`.
+- If you cannot move the allocation, you can set `pass.pMoves[i].operation` to #VMA_DEFRAGMENTATION_MOVE_OPERATION_IGNORE.
+  This will cancel the move.
+  - vmaEndDefragmentationPass() will then free the destination memory
+    not the source memory of the allocation, leaving it unchanged.
+- If you decide the allocation is unimportant and can be destroyed instead of moved (e.g. it wasn't used for long time),
+  you can set `pass.pMoves[i].operation` to #VMA_DEFRAGMENTATION_MOVE_OPERATION_DESTROY.
+  - vmaEndDefragmentationPass() will then free both source and destination memory, and will destroy the source #VmaAllocation object.
+
+You can defragment a specific custom pool by setting VmaDefragmentationInfo::pool
+(like in the example above) or all the default pools by setting this member to null.
+
+Defragmentation is always performed in each pool separately.
+Allocations are never moved between different Vulkan memory types.
+The size of the destination memory reserved for a moved allocation is the same as the original one.
+Alignment of an allocation as it was determined using `vkGetBufferMemoryRequirements()` etc. is also respected after defragmentation.
+Buffers/images should be recreated with the same `VkBufferCreateInfo` / `VkImageCreateInfo` parameters as the original ones.
+
+You can perform the defragmentation incrementally to limit the number of allocations and bytes to be moved
+in each pass, e.g. to call it in sync with render frames and not to experience too big hitches.
+See members: VmaDefragmentationInfo::maxBytesPerPass, VmaDefragmentationInfo::maxAllocationsPerPass.
+
+It is also safe to perform the defragmentation asynchronously to render frames and other Vulkan and VMA
+usage, possibly from multiple threads, with the exception that allocations
+returned in VmaDefragmentationPassMoveInfo::pMoves shouldn't be destroyed until the defragmentation pass is ended.
+
+<b>Mapping</b> is preserved on allocations that are moved during defragmentation.
+Whether through #VMA_ALLOCATION_CREATE_MAPPED_BIT or vmaMapMemory(), the allocations
+are mapped at their new place. Of course, pointer to the mapped data changes, so it needs to be queried
+using VmaAllocationInfo::pMappedData.
+
+\note Defragmentation is not supported in custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT.
+
+
+\page statistics Statistics
+
+This library contains several functions that return information about its internal state,
+especially the amount of memory allocated from Vulkan.
+
+\section statistics_numeric_statistics Numeric statistics
+
+If you need to obtain basic statistics about memory usage per heap, together with current budget,
+you can call function vmaGetHeapBudgets() and inspect structure #VmaBudget.
+This is useful to keep track of memory usage and stay withing budget
+(see also \ref staying_within_budget).
+Example:
+
+\code
+uint32_t heapIndex = ...
+
+VmaBudget budgets[VK_MAX_MEMORY_HEAPS];
+vmaGetHeapBudgets(allocator, budgets);
+
+printf("My heap currently has %u allocations taking %llu B,\n",
+    budgets[heapIndex].statistics.allocationCount,
+    budgets[heapIndex].statistics.allocationBytes);
+printf("allocated out of %u Vulkan device memory blocks taking %llu B,\n",
+    budgets[heapIndex].statistics.blockCount,
+    budgets[heapIndex].statistics.blockBytes);
+printf("Vulkan reports total usage %llu B with budget %llu B.\n",
+    budgets[heapIndex].usage,
+    budgets[heapIndex].budget);
+\endcode
+
+You can query for more detailed statistics per memory heap, type, and totals,
+including minimum and maximum allocation size and unused range size,
+by calling function vmaCalculateStatistics() and inspecting structure #VmaTotalStatistics.
+This function is slower though, as it has to traverse all the internal data structures,
+so it should be used only for debugging purposes.
+
+You can query for statistics of a custom pool using function vmaGetPoolStatistics()
+or vmaCalculatePoolStatistics().
+
+You can query for information about a specific allocation using function vmaGetAllocationInfo().
+It fill structure #VmaAllocationInfo.
+
+\section statistics_json_dump JSON dump
+
+You can dump internal state of the allocator to a string in JSON format using function vmaBuildStatsString().
+The result is guaranteed to be correct JSON.
+It uses ANSI encoding.
+Any strings provided by user (see [Allocation names](@ref allocation_names))
+are copied as-is and properly escaped for JSON, so if they use UTF-8, ISO-8859-2 or any other encoding,
+this JSON string can be treated as using this encoding.
+It must be freed using function vmaFreeStatsString().
+
+The format of this JSON string is not part of official documentation of the library,
+but it will not change in backward-incompatible way without increasing library major version number
+and appropriate mention in changelog.
+
+The JSON string contains all the data that can be obtained using vmaCalculateStatistics().
+It can also contain detailed map of allocated memory blocks and their regions -
+free and occupied by allocations.
+This allows e.g. to visualize the memory or assess fragmentation.
+
+
+\page allocation_annotation Allocation names and user data
+
+\section allocation_user_data Allocation user data
+
+You can annotate allocations with your own information, e.g. for debugging purposes.
+To do that, fill VmaAllocationCreateInfo::pUserData field when creating
+an allocation. It is an opaque `void*` pointer. You can use it e.g. as a pointer,
+some handle, index, key, ordinal number or any other value that would associate
+the allocation with your custom metadata.
+It it useful to identify appropriate data structures in your engine given #VmaAllocation,
+e.g. when doing \ref defragmentation.
+
+\code
+VkBufferCreateInfo bufCreateInfo = ...
+
+MyBufferMetadata* pMetadata = CreateBufferMetadata();
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.pUserData = pMetadata;
+
+VkBuffer buffer;
+VmaAllocation allocation;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buffer, &allocation, nullptr);
+\endcode
+
+The pointer may be later retrieved as VmaAllocationInfo::pUserData:
+
+\code
+VmaAllocationInfo allocInfo;
+vmaGetAllocationInfo(allocator, allocation, &allocInfo);
+MyBufferMetadata* pMetadata = (MyBufferMetadata*)allocInfo.pUserData;
+\endcode
+
+It can also be changed using function vmaSetAllocationUserData().
+
+Values of (non-zero) allocations' `pUserData` are printed in JSON report created by
+vmaBuildStatsString() in hexadecimal form.
+
+\section allocation_names Allocation names
+
+An allocation can also carry a null-terminated string, giving a name to the allocation.
+To set it, call vmaSetAllocationName().
+The library creates internal copy of the string, so the pointer you pass doesn't need
+to be valid for whole lifetime of the allocation. You can free it after the call.
+
+\code
+std::string imageName = "Texture: ";
+imageName += fileName;
+vmaSetAllocationName(allocator, allocation, imageName.c_str());
+\endcode
+
+The string can be later retrieved by inspecting VmaAllocationInfo::pName.
+It is also printed in JSON report created by vmaBuildStatsString().
+
+\note Setting string name to VMA allocation doesn't automatically set it to the Vulkan buffer or image created with it.
+You must do it manually using an extension like VK_EXT_debug_utils, which is independent of this library.
+
+
+\page virtual_allocator Virtual allocator
+
+As an extra feature, the core allocation algorithm of the library is exposed through a simple and convenient API of "virtual allocator".
+It doesn't allocate any real GPU memory. It just keeps track of used and free regions of a "virtual block".
+You can use it to allocate your own memory or other objects, even completely unrelated to Vulkan.
+A common use case is sub-allocation of pieces of one large GPU buffer.
+
+\section virtual_allocator_creating_virtual_block Creating virtual block
+
+To use this functionality, there is no main "allocator" object.
+You don't need to have #VmaAllocator object created.
+All you need to do is to create a separate #VmaVirtualBlock object for each block of memory you want to be managed by the allocator:
+
+-# Fill in #VmaVirtualBlockCreateInfo structure.
+-# Call vmaCreateVirtualBlock(). Get new #VmaVirtualBlock object.
+
+Example:
+
+\code
+VmaVirtualBlockCreateInfo blockCreateInfo = {};
+blockCreateInfo.size = 1048576; // 1 MB
+
+VmaVirtualBlock block;
+VkResult res = vmaCreateVirtualBlock(&blockCreateInfo, &block);
+\endcode
+
+\section virtual_allocator_making_virtual_allocations Making virtual allocations
+
+#VmaVirtualBlock object contains internal data structure that keeps track of free and occupied regions
+using the same code as the main Vulkan memory allocator.
+Similarly to #VmaAllocation for standard GPU allocations, there is #VmaVirtualAllocation type
+that represents an opaque handle to an allocation withing the virtual block.
+
+In order to make such allocation:
+
+-# Fill in #VmaVirtualAllocationCreateInfo structure.
+-# Call vmaVirtualAllocate(). Get new #VmaVirtualAllocation object that represents the allocation.
+   You can also receive `VkDeviceSize offset` that was assigned to the allocation.
+
+Example:
+
+\code
+VmaVirtualAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.size = 4096; // 4 KB
+
+VmaVirtualAllocation alloc;
+VkDeviceSize offset;
+res = vmaVirtualAllocate(block, &allocCreateInfo, &alloc, &offset);
+if(res == VK_SUCCESS)
+{
+    // Use the 4 KB of your memory starting at offset.
+}
+else
+{
+    // Allocation failed - no space for it could be found. Handle this error!
+}
+\endcode
+
+\section virtual_allocator_deallocation Deallocation
+
+When no longer needed, an allocation can be freed by calling vmaVirtualFree().
+You can only pass to this function an allocation that was previously returned by vmaVirtualAllocate()
+called for the same #VmaVirtualBlock.
+
+When whole block is no longer needed, the block object can be released by calling vmaDestroyVirtualBlock().
+All allocations must be freed before the block is destroyed, which is checked internally by an assert.
+However, if you don't want to call vmaVirtualFree() for each allocation, you can use vmaClearVirtualBlock() to free them all at once -
+a feature not available in normal Vulkan memory allocator. Example:
+
+\code
+vmaVirtualFree(block, alloc);
+vmaDestroyVirtualBlock(block);
+\endcode
+
+\section virtual_allocator_allocation_parameters Allocation parameters
+
+You can attach a custom pointer to each allocation by using vmaSetVirtualAllocationUserData().
+Its default value is null.
+It can be used to store any data that needs to be associated with that allocation - e.g. an index, a handle, or a pointer to some
+larger data structure containing more information. Example:
+
+\code
+struct CustomAllocData
+{
+    std::string m_AllocName;
+};
+CustomAllocData* allocData = new CustomAllocData();
+allocData->m_AllocName = "My allocation 1";
+vmaSetVirtualAllocationUserData(block, alloc, allocData);
+\endcode
+
+The pointer can later be fetched, along with allocation offset and size, by passing the allocation handle to function
+vmaGetVirtualAllocationInfo() and inspecting returned structure #VmaVirtualAllocationInfo.
+If you allocated a new object to be used as the custom pointer, don't forget to delete that object before freeing the allocation!
+Example:
+
+\code
+VmaVirtualAllocationInfo allocInfo;
+vmaGetVirtualAllocationInfo(block, alloc, &allocInfo);
+delete (CustomAllocData*)allocInfo.pUserData;
+
+vmaVirtualFree(block, alloc);
+\endcode
+
+\section virtual_allocator_alignment_and_units Alignment and units
+
+It feels natural to express sizes and offsets in bytes.
+If an offset of an allocation needs to be aligned to a multiply of some number (e.g. 4 bytes), you can fill optional member
+VmaVirtualAllocationCreateInfo::alignment to request it. Example:
+
+\code
+VmaVirtualAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.size = 4096; // 4 KB
+allocCreateInfo.alignment = 4; // Returned offset must be a multiply of 4 B
+
+VmaVirtualAllocation alloc;
+res = vmaVirtualAllocate(block, &allocCreateInfo, &alloc, nullptr);
+\endcode
+
+Alignments of different allocations made from one block may vary.
+However, if all alignments and sizes are always multiply of some size e.g. 4 B or `sizeof(MyDataStruct)`,
+you can express all sizes, alignments, and offsets in multiples of that size instead of individual bytes.
+It might be more convenient, but you need to make sure to use this new unit consistently in all the places:
+
+- VmaVirtualBlockCreateInfo::size
+- VmaVirtualAllocationCreateInfo::size and VmaVirtualAllocationCreateInfo::alignment
+- Using offset returned by vmaVirtualAllocate() or in VmaVirtualAllocationInfo::offset
+
+\section virtual_allocator_statistics Statistics
+
+You can obtain statistics of a virtual block using vmaGetVirtualBlockStatistics()
+(to get brief statistics that are fast to calculate)
+or vmaCalculateVirtualBlockStatistics() (to get more detailed statistics, slower to calculate).
+The functions fill structures #VmaStatistics, #VmaDetailedStatistics respectively - same as used by the normal Vulkan memory allocator.
+Example:
+
+\code
+VmaStatistics stats;
+vmaGetVirtualBlockStatistics(block, &stats);
+printf("My virtual block has %llu bytes used by %u virtual allocations\n",
+    stats.allocationBytes, stats.allocationCount);
+\endcode
+
+You can also request a full list of allocations and free regions as a string in JSON format by calling
+vmaBuildVirtualBlockStatsString().
+Returned string must be later freed using vmaFreeVirtualBlockStatsString().
+The format of this string differs from the one returned by the main Vulkan allocator, but it is similar.
+
+\section virtual_allocator_additional_considerations Additional considerations
+
+The "virtual allocator" functionality is implemented on a level of individual memory blocks.
+Keeping track of a whole collection of blocks, allocating new ones when out of free space,
+deleting empty ones, and deciding which one to try first for a new allocation must be implemented by the user.
+
+Alternative allocation algorithms are supported, just like in custom pools of the real GPU memory.
+See enum #VmaVirtualBlockCreateFlagBits to learn how to specify them (e.g. #VMA_VIRTUAL_BLOCK_CREATE_LINEAR_ALGORITHM_BIT).
+You can find their description in chapter \ref custom_memory_pools.
+Allocation strategies are also supported.
+See enum #VmaVirtualAllocationCreateFlagBits to learn how to specify them (e.g. #VMA_VIRTUAL_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT).
+
+Following features are supported only by the allocator of the real GPU memory and not by virtual allocations:
+buffer-image granularity, `VMA_DEBUG_MARGIN`, `VMA_MIN_ALIGNMENT`.
+
+
+\page debugging_memory_usage Debugging incorrect memory usage
+
+If you suspect a bug with memory usage, like usage of uninitialized memory or
+memory being overwritten out of bounds of an allocation,
+you can use debug features of this library to verify this.
+
+\section debugging_memory_usage_initialization Memory initialization
+
+If you experience a bug with incorrect and nondeterministic data in your program and you suspect uninitialized memory to be used,
+you can enable automatic memory initialization to verify this.
+To do it, define macro `VMA_DEBUG_INITIALIZE_ALLOCATIONS` to 1.
+
+\code
+#define VMA_DEBUG_INITIALIZE_ALLOCATIONS 1
+#include "vk_mem_alloc.h"
+\endcode
+
+It makes memory of new allocations initialized to bit pattern `0xDCDCDCDC`.
+Before an allocation is destroyed, its memory is filled with bit pattern `0xEFEFEFEF`.
+Memory is automatically mapped and unmapped if necessary.
+
+If you find these values while debugging your program, good chances are that you incorrectly
+read Vulkan memory that is allocated but not initialized, or already freed, respectively.
+
+Memory initialization works only with memory types that are `HOST_VISIBLE` and with allocations that can be mapped.
+It works also with dedicated allocations.
+
+\section debugging_memory_usage_margins Margins
+
+By default, allocations are laid out in memory blocks next to each other if possible
+(considering required alignment, `bufferImageGranularity`, and `nonCoherentAtomSize`).
+
+![Allocations without margin](../gfx/Margins_1.png)
+
+Define macro `VMA_DEBUG_MARGIN` to some non-zero value (e.g. 16) to enforce specified
+number of bytes as a margin after every allocation.
+
+\code
+#define VMA_DEBUG_MARGIN 16
+#include "vk_mem_alloc.h"
+\endcode
+
+![Allocations with margin](../gfx/Margins_2.png)
+
+If your bug goes away after enabling margins, it means it may be caused by memory
+being overwritten outside of allocation boundaries. It is not 100% certain though.
+Change in application behavior may also be caused by different order and distribution
+of allocations across memory blocks after margins are applied.
+
+Margins work with all types of memory.
+
+Margin is applied only to allocations made out of memory blocks and not to dedicated
+allocations, which have their own memory block of specific size.
+It is thus not applied to allocations made using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT flag
+or those automatically decided to put into dedicated allocations, e.g. due to its
+large size or recommended by VK_KHR_dedicated_allocation extension.
+
+Margins appear in [JSON dump](@ref statistics_json_dump) as part of free space.
+
+Note that enabling margins increases memory usage and fragmentation.
+
+Margins do not apply to \ref virtual_allocator.
+
+\section debugging_memory_usage_corruption_detection Corruption detection
+
+You can additionally define macro `VMA_DEBUG_DETECT_CORRUPTION` to 1 to enable validation
+of contents of the margins.
+
+\code
+#define VMA_DEBUG_MARGIN 16
+#define VMA_DEBUG_DETECT_CORRUPTION 1
+#include "vk_mem_alloc.h"
+\endcode
+
+When this feature is enabled, number of bytes specified as `VMA_DEBUG_MARGIN`
+(it must be multiply of 4) after every allocation is filled with a magic number.
+This idea is also know as "canary".
+Memory is automatically mapped and unmapped if necessary.
+
+This number is validated automatically when the allocation is destroyed.
+If it is not equal to the expected value, `VMA_ASSERT()` is executed.
+It clearly means that either CPU or GPU overwritten the memory outside of boundaries of the allocation,
+which indicates a serious bug.
+
+You can also explicitly request checking margins of all allocations in all memory blocks
+that belong to specified memory types by using function vmaCheckCorruption(),
+or in memory blocks that belong to specified custom pool, by using function
+vmaCheckPoolCorruption().
+
+Margin validation (corruption detection) works only for memory types that are
+`HOST_VISIBLE` and `HOST_COHERENT`.
+
+
+\page opengl_interop OpenGL Interop
+
+VMA provides some features that help with interoperability with OpenGL.
+
+\section opengl_interop_exporting_memory Exporting memory
+
+If you want to attach `VkExportMemoryAllocateInfoKHR` structure to `pNext` chain of memory allocations made by the library:
+
+It is recommended to create \ref custom_memory_pools for such allocations.
+Define and fill in your `VkExportMemoryAllocateInfoKHR` structure and attach it to VmaPoolCreateInfo::pMemoryAllocateNext
+while creating the custom pool.
+Please note that the structure must remain alive and unchanged for the whole lifetime of the #VmaPool,
+not only while creating it, as no copy of the structure is made,
+but its original pointer is used for each allocation instead.
+
+If you want to export all memory allocated by the library from certain memory types,
+also dedicated allocations or other allocations made from default pools,
+an alternative solution is to fill in VmaAllocatorCreateInfo::pTypeExternalMemoryHandleTypes.
+It should point to an array with `VkExternalMemoryHandleTypeFlagsKHR` to be automatically passed by the library
+through `VkExportMemoryAllocateInfoKHR` on each allocation made from a specific memory type.
+Please note that new versions of the library also support dedicated allocations created in custom pools.
+
+You should not mix these two methods in a way that allows to apply both to the same memory type.
+Otherwise, `VkExportMemoryAllocateInfoKHR` structure would be attached twice to the `pNext` chain of `VkMemoryAllocateInfo`.
+
+
+\section opengl_interop_custom_alignment Custom alignment
+
+Buffers or images exported to a different API like OpenGL may require a different alignment,
+higher than the one used by the library automatically, queried from functions like `vkGetBufferMemoryRequirements`.
+To impose such alignment:
+
+It is recommended to create \ref custom_memory_pools for such allocations.
+Set VmaPoolCreateInfo::minAllocationAlignment member to the minimum alignment required for each allocation
+to be made out of this pool.
+The alignment actually used will be the maximum of this member and the alignment returned for the specific buffer or image
+from a function like `vkGetBufferMemoryRequirements`, which is called by VMA automatically.
+
+If you want to create a buffer with a specific minimum alignment out of default pools,
+use special function vmaCreateBufferWithAlignment(), which takes additional parameter `minAlignment`.
+
+Note the problem of alignment affects only resources placed inside bigger `VkDeviceMemory` blocks and not dedicated
+allocations, as these, by definition, always have alignment = 0 because the resource is bound to the beginning of its dedicated block.
+Contrary to Direct3D 12, Vulkan doesn't have a concept of alignment of the entire memory block passed on its allocation.
+
+
+\page usage_patterns Recommended usage patterns
+
+Vulkan gives great flexibility in memory allocation.
+This chapter shows the most common patterns.
+
+See also slides from talk:
+[Sawicki, Adam. Advanced Graphics Techniques Tutorial: Memory management in Vulkan and DX12. Game Developers Conference, 2018](https://www.gdcvault.com/play/1025458/Advanced-Graphics-Techniques-Tutorial-New)
+
+
+\section usage_patterns_gpu_only GPU-only resource
+
+<b>When:</b>
+Any resources that you frequently write and read on GPU,
+e.g. images used as color attachments (aka "render targets"), depth-stencil attachments,
+images/buffers used as storage image/buffer (aka "Unordered Access View (UAV)").
+
+<b>What to do:</b>
+Let the library select the optimal memory type, which will likely have `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.
+
+\code
+VkImageCreateInfo imgCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+imgCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+imgCreateInfo.extent.width = 3840;
+imgCreateInfo.extent.height = 2160;
+imgCreateInfo.extent.depth = 1;
+imgCreateInfo.mipLevels = 1;
+imgCreateInfo.arrayLayers = 1;
+imgCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
+imgCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+imgCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+imgCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+imgCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+allocCreateInfo.priority = 1.0f;
+
+VkImage img;
+VmaAllocation alloc;
+vmaCreateImage(allocator, &imgCreateInfo, &allocCreateInfo, &img, &alloc, nullptr);
+\endcode
+
+<b>Also consider:</b>
+Consider creating them as dedicated allocations using #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
+especially if they are large or if you plan to destroy and recreate them with different sizes
+e.g. when display resolution changes.
+Prefer to create such resources first and all other GPU resources (like textures and vertex buffers) later.
+When VK_EXT_memory_priority extension is enabled, it is also worth setting high priority to such allocation
+to decrease chances to be evicted to system memory by the operating system.
+
+\section usage_patterns_staging_copy_upload Staging copy for upload
+
+<b>When:</b>
+A "staging" buffer than you want to map and fill from CPU code, then use as a source od transfer
+to some GPU resource.
+
+<b>What to do:</b>
+Use flag #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT.
+Let the library select the optimal memory type, which will always have `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`.
+
+\code
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = 65536;
+bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
+    VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
+...
+
+memcpy(allocInfo.pMappedData, myData, myDataSize);
+\endcode
+
+<b>Also consider:</b>
+You can map the allocation using vmaMapMemory() or you can create it as persistenly mapped
+using #VMA_ALLOCATION_CREATE_MAPPED_BIT, as in the example above.
+
+
+\section usage_patterns_readback Readback
+
+<b>When:</b>
+Buffers for data written by or transferred from the GPU that you want to read back on the CPU,
+e.g. results of some computations.
+
+<b>What to do:</b>
+Use flag #VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT.
+Let the library select the optimal memory type, which will always have `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT`
+and `VK_MEMORY_PROPERTY_HOST_CACHED_BIT`.
+
+\code
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = 65536;
+bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT |
+    VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
+...
+
+const float* downloadedData = (const float*)allocInfo.pMappedData;
+\endcode
+
+
+\section usage_patterns_advanced_data_uploading Advanced data uploading
+
+For resources that you frequently write on CPU via mapped pointer and
+freqnently read on GPU e.g. as a uniform buffer (also called "dynamic"), multiple options are possible:
+
+-# Easiest solution is to have one copy of the resource in `HOST_VISIBLE` memory,
+   even if it means system RAM (not `DEVICE_LOCAL`) on systems with a discrete graphics card,
+   and make the device reach out to that resource directly.
+   - Reads performed by the device will then go through PCI Express bus.
+     The performace of this access may be limited, but it may be fine depending on the size
+     of this resource (whether it is small enough to quickly end up in GPU cache) and the sparsity
+     of access.
+-# On systems with unified memory (e.g. AMD APU or Intel integrated graphics, mobile chips),
+   a memory type may be available that is both `HOST_VISIBLE` (available for mapping) and `DEVICE_LOCAL`
+   (fast to access from the GPU). Then, it is likely the best choice for such type of resource.
+-# Systems with a discrete graphics card and separate video memory may or may not expose
+   a memory type that is both `HOST_VISIBLE` and `DEVICE_LOCAL`, also known as Base Address Register (BAR).
+   If they do, it represents a piece of VRAM (or entire VRAM, if ReBAR is enabled in the motherboard BIOS)
+   that is available to CPU for mapping.
+   - Writes performed by the host to that memory go through PCI Express bus.
+     The performance of these writes may be limited, but it may be fine, especially on PCIe 4.0,
+     as long as rules of using uncached and write-combined memory are followed - only sequential writes and no reads.
+-# Finally, you may need or prefer to create a separate copy of the resource in `DEVICE_LOCAL` memory,
+   a separate "staging" copy in `HOST_VISIBLE` memory and perform an explicit transfer command between them.
+
+Thankfully, VMA offers an aid to create and use such resources in the the way optimal
+for the current Vulkan device. To help the library make the best choice,
+use flag #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT together with
+#VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT.
+It will then prefer a memory type that is both `DEVICE_LOCAL` and `HOST_VISIBLE` (integrated memory or BAR),
+but if no such memory type is available or allocation from it fails
+(PC graphics cards have only 256 MB of BAR by default, unless ReBAR is supported and enabled in BIOS),
+it will fall back to `DEVICE_LOCAL` memory for fast GPU access.
+It is then up to you to detect that the allocation ended up in a memory type that is not `HOST_VISIBLE`,
+so you need to create another "staging" allocation and perform explicit transfers.
+
+\code
+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+bufCreateInfo.size = 65536;
+bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+ 
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
+    VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT |
+    VMA_ALLOCATION_CREATE_MAPPED_BIT;
+ 
+VkBuffer buf;
+VmaAllocation alloc;
+VmaAllocationInfo allocInfo;
+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
+VkMemoryPropertyFlags memPropFlags;
+vmaGetAllocationMemoryProperties(allocator, alloc, &memPropFlags);
+
+if(memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+{
+    // Allocation ended up in a mappable memory and is already mapped - write to it directly.
+
+    // [Executed in runtime]:
+    memcpy(allocInfo.pMappedData, myData, myDataSize);
+}
+else
+{
+    // Allocation ended up in a non-mappable memory - need to transfer.
+    VkBufferCreateInfo stagingBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+    stagingBufCreateInfo.size = 65536;
+    stagingBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+    VmaAllocationCreateInfo stagingAllocCreateInfo = {};
+    stagingAllocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+    stagingAllocCreateInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
+        VMA_ALLOCATION_CREATE_MAPPED_BIT;
+
+    VkBuffer stagingBuf;
+    VmaAllocation stagingAlloc;
+    VmaAllocationInfo stagingAllocInfo;
+    vmaCreateBuffer(allocator, &stagingBufCreateInfo, &stagingAllocCreateInfo,
+        &stagingBuf, &stagingAlloc, stagingAllocInfo);
+
+    // [Executed in runtime]:
+    memcpy(stagingAllocInfo.pMappedData, myData, myDataSize);
+    //vkCmdPipelineBarrier: VK_ACCESS_HOST_WRITE_BIT --> VK_ACCESS_TRANSFER_READ_BIT
+    VkBufferCopy bufCopy = {
+        0, // srcOffset
+        0, // dstOffset,
+        myDataSize); // size
+    vkCmdCopyBuffer(cmdBuf, stagingBuf, buf, 1, &bufCopy);
+}
+\endcode
+
+\section usage_patterns_other_use_cases Other use cases
+
+Here are some other, less obvious use cases and their recommended settings:
+
+- An image that is used only as transfer source and destination, but it should stay on the device,
+  as it is used to temporarily store a copy of some texture, e.g. from the current to the next frame,
+  for temporal antialiasing or other temporal effects.
+  - Use `VkImageCreateInfo::usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT`
+  - Use VmaAllocationCreateInfo::usage = #VMA_MEMORY_USAGE_AUTO
+- An image that is used only as transfer source and destination, but it should be placed
+  in the system RAM despite it doesn't need to be mapped, because it serves as a "swap" copy to evict
+  least recently used textures from VRAM.
+  - Use `VkImageCreateInfo::usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT`
+  - Use VmaAllocationCreateInfo::usage = #VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
+    as VMA needs a hint here to differentiate from the previous case.
+- A buffer that you want to map and write from the CPU, directly read from the GPU
+  (e.g. as a uniform or vertex buffer), but you have a clear preference to place it in device or
+  host memory due to its large size.
+  - Use `VkBufferCreateInfo::usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT`
+  - Use VmaAllocationCreateInfo::usage = #VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE or #VMA_MEMORY_USAGE_AUTO_PREFER_HOST
+  - Use VmaAllocationCreateInfo::flags = #VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT
+
+
+\page configuration Configuration
+
+Please check "CONFIGURATION SECTION" in the code to find macros that you can define
+before each include of this file or change directly in this file to provide
+your own implementation of basic facilities like assert, `min()` and `max()` functions,
+mutex, atomic etc.
+The library uses its own implementation of containers by default, but you can switch to using
+STL containers instead.
+
+For example, define `VMA_ASSERT(expr)` before including the library to provide
+custom implementation of the assertion, compatible with your project.
+By default it is defined to standard C `assert(expr)` in `_DEBUG` configuration
+and empty otherwise.
+
+\section config_Vulkan_functions Pointers to Vulkan functions
+
+There are multiple ways to import pointers to Vulkan functions in the library.
+In the simplest case you don't need to do anything.
+If the compilation or linking of your program or the initialization of the #VmaAllocator
+doesn't work for you, you can try to reconfigure it.
+
+First, the allocator tries to fetch pointers to Vulkan functions linked statically,
+like this:
+
+\code
+m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
+\endcode
+
+If you want to disable this feature, set configuration macro: `#define VMA_STATIC_VULKAN_FUNCTIONS 0`.
+
+Second, you can provide the pointers yourself by setting member VmaAllocatorCreateInfo::pVulkanFunctions.
+You can fetch them e.g. using functions `vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` or
+by using a helper library like [volk](https://github.com/zeux/volk).
+
+Third, VMA tries to fetch remaining pointers that are still null by calling
+`vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` on its own.
+You need to only fill in VmaVulkanFunctions::vkGetInstanceProcAddr and VmaVulkanFunctions::vkGetDeviceProcAddr.
+Other pointers will be fetched automatically.
+If you want to disable this feature, set configuration macro: `#define VMA_DYNAMIC_VULKAN_FUNCTIONS 0`.
+
+Finally, all the function pointers required by the library (considering selected
+Vulkan version and enabled extensions) are checked with `VMA_ASSERT` if they are not null.
+
+
+\section custom_memory_allocator Custom host memory allocator
+
+If you use custom allocator for CPU memory rather than default operator `new`
+and `delete` from C++, you can make this library using your allocator as well
+by filling optional member VmaAllocatorCreateInfo::pAllocationCallbacks. These
+functions will be passed to Vulkan, as well as used by the library itself to
+make any CPU-side allocations.
+
+\section allocation_callbacks Device memory allocation callbacks
+
+The library makes calls to `vkAllocateMemory()` and `vkFreeMemory()` internally.
+You can setup callbacks to be informed about these calls, e.g. for the purpose
+of gathering some statistics. To do it, fill optional member
+VmaAllocatorCreateInfo::pDeviceMemoryCallbacks.
+
+\section heap_memory_limit Device heap memory limit
+
+When device memory of certain heap runs out of free space, new allocations may
+fail (returning error code) or they may succeed, silently pushing some existing_
+memory blocks from GPU VRAM to system RAM (which degrades performance). This
+behavior is implementation-dependent - it depends on GPU vendor and graphics
+driver.
+
+On AMD cards it can be controlled while creating Vulkan device object by using
+VK_AMD_memory_overallocation_behavior extension, if available.
+
+Alternatively, if you want to test how your program behaves with limited amount of Vulkan device
+memory available without switching your graphics card to one that really has
+smaller VRAM, you can use a feature of this library intended for this purpose.
+To do it, fill optional member VmaAllocatorCreateInfo::pHeapSizeLimit.
+
+
+
+\page vk_khr_dedicated_allocation VK_KHR_dedicated_allocation
+
+VK_KHR_dedicated_allocation is a Vulkan extension which can be used to improve
+performance on some GPUs. It augments Vulkan API with possibility to query
+driver whether it prefers particular buffer or image to have its own, dedicated
+allocation (separate `VkDeviceMemory` block) for better efficiency - to be able
+to do some internal optimizations. The extension is supported by this library.
+It will be used automatically when enabled.
+
+It has been promoted to core Vulkan 1.1, so if you use eligible Vulkan version
+and inform VMA about it by setting VmaAllocatorCreateInfo::vulkanApiVersion,
+you are all set.
+
+Otherwise, if you want to use it as an extension:
+
+1 . When creating Vulkan device, check if following 2 device extensions are
+supported (call `vkEnumerateDeviceExtensionProperties()`).
+If yes, enable them (fill `VkDeviceCreateInfo::ppEnabledExtensionNames`).
+
+- VK_KHR_get_memory_requirements2
+- VK_KHR_dedicated_allocation
+
+If you enabled these extensions:
+
+2 . Use #VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag when creating
+your #VmaAllocator to inform the library that you enabled required extensions
+and you want the library to use them.
+
+\code
+allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT;
+
+vmaCreateAllocator(&allocatorInfo, &allocator);
+\endcode
+
+That is all. The extension will be automatically used whenever you create a
+buffer using vmaCreateBuffer() or image using vmaCreateImage().
+
+When using the extension together with Vulkan Validation Layer, you will receive
+warnings like this:
+
+_vkBindBufferMemory(): Binding memory to buffer 0x33 but vkGetBufferMemoryRequirements() has not been called on that buffer._
+
+It is OK, you should just ignore it. It happens because you use function
+`vkGetBufferMemoryRequirements2KHR()` instead of standard
+`vkGetBufferMemoryRequirements()`, while the validation layer seems to be
+unaware of it.
+
+To learn more about this extension, see:
+
+- [VK_KHR_dedicated_allocation in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/chap50.html#VK_KHR_dedicated_allocation)
+- [VK_KHR_dedicated_allocation unofficial manual](http://asawicki.info/articles/VK_KHR_dedicated_allocation.php5)
+
+
+
+\page vk_ext_memory_priority VK_EXT_memory_priority
+
+VK_EXT_memory_priority is a device extension that allows to pass additional "priority"
+value to Vulkan memory allocations that the implementation may use prefer certain
+buffers and images that are critical for performance to stay in device-local memory
+in cases when the memory is over-subscribed, while some others may be moved to the system memory.
+
+VMA offers convenient usage of this extension.
+If you enable it, you can pass "priority" parameter when creating allocations or custom pools
+and the library automatically passes the value to Vulkan using this extension.
+
+If you want to use this extension in connection with VMA, follow these steps:
+
+\section vk_ext_memory_priority_initialization Initialization
+
+1) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
+Check if the extension is supported - if returned array of `VkExtensionProperties` contains "VK_EXT_memory_priority".
+
+2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
+Attach additional structure `VkPhysicalDeviceMemoryPriorityFeaturesEXT` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
+Check if the device feature is really supported - check if `VkPhysicalDeviceMemoryPriorityFeaturesEXT::memoryPriority` is true.
+
+3) While creating device with `vkCreateDevice`, enable this extension - add "VK_EXT_memory_priority"
+to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.
+
+4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
+Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
+Enable this device feature - attach additional structure `VkPhysicalDeviceMemoryPriorityFeaturesEXT` to
+`VkPhysicalDeviceFeatures2::pNext` chain and set its member `memoryPriority` to `VK_TRUE`.
+
+5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
+have enabled this extension and feature - add #VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT
+to VmaAllocatorCreateInfo::flags.
+
+\section vk_ext_memory_priority_usage Usage
+
+When using this extension, you should initialize following member:
+
+- VmaAllocationCreateInfo::priority when creating a dedicated allocation with #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+- VmaPoolCreateInfo::priority when creating a custom pool.
+
+It should be a floating-point value between `0.0f` and `1.0f`, where recommended default is `0.5f`.
+Memory allocated with higher value can be treated by the Vulkan implementation as higher priority
+and so it can have lower chances of being pushed out to system memory, experiencing degraded performance.
+
+It might be a good idea to create performance-critical resources like color-attachment or depth-stencil images
+as dedicated and set high priority to them. For example:
+
+\code
+VkImageCreateInfo imgCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+imgCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+imgCreateInfo.extent.width = 3840;
+imgCreateInfo.extent.height = 2160;
+imgCreateInfo.extent.depth = 1;
+imgCreateInfo.mipLevels = 1;
+imgCreateInfo.arrayLayers = 1;
+imgCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
+imgCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+imgCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+imgCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+imgCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+
+VmaAllocationCreateInfo allocCreateInfo = {};
+allocCreateInfo.usage = VMA_MEMORY_USAGE_AUTO;
+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+allocCreateInfo.priority = 1.0f;
+
+VkImage img;
+VmaAllocation alloc;
+vmaCreateImage(allocator, &imgCreateInfo, &allocCreateInfo, &img, &alloc, nullptr);
+\endcode
+
+`priority` member is ignored in the following situations:
+
+- Allocations created in custom pools: They inherit the priority, along with all other allocation parameters
+  from the parametrs passed in #VmaPoolCreateInfo when the pool was created.
+- Allocations created in default pools: They inherit the priority from the parameters
+  VMA used when creating default pools, which means `priority == 0.5f`.
+
+
+\page vk_amd_device_coherent_memory VK_AMD_device_coherent_memory
+
+VK_AMD_device_coherent_memory is a device extension that enables access to
+additional memory types with `VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD` and
+`VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` flag. It is useful mostly for
+allocation of buffers intended for writing "breadcrumb markers" in between passes
+or draw calls, which in turn are useful for debugging GPU crash/hang/TDR cases.
+
+When the extension is available but has not been enabled, Vulkan physical device
+still exposes those memory types, but their usage is forbidden. VMA automatically
+takes care of that - it returns `VK_ERROR_FEATURE_NOT_PRESENT` when an attempt
+to allocate memory of such type is made.
+
+If you want to use this extension in connection with VMA, follow these steps:
+
+\section vk_amd_device_coherent_memory_initialization Initialization
+
+1) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
+Check if the extension is supported - if returned array of `VkExtensionProperties` contains "VK_AMD_device_coherent_memory".
+
+2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
+Attach additional structure `VkPhysicalDeviceCoherentMemoryFeaturesAMD` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
+Check if the device feature is really supported - check if `VkPhysicalDeviceCoherentMemoryFeaturesAMD::deviceCoherentMemory` is true.
+
+3) While creating device with `vkCreateDevice`, enable this extension - add "VK_AMD_device_coherent_memory"
+to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.
+
+4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
+Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
+Enable this device feature - attach additional structure `VkPhysicalDeviceCoherentMemoryFeaturesAMD` to
+`VkPhysicalDeviceFeatures2::pNext` and set its member `deviceCoherentMemory` to `VK_TRUE`.
+
+5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
+have enabled this extension and feature - add #VMA_ALLOCATOR_CREATE_AMD_DEVICE_COHERENT_MEMORY_BIT
+to VmaAllocatorCreateInfo::flags.
+
+\section vk_amd_device_coherent_memory_usage Usage
+
+After following steps described above, you can create VMA allocations and custom pools
+out of the special `DEVICE_COHERENT` and `DEVICE_UNCACHED` memory types on eligible
+devices. There are multiple ways to do it, for example:
+
+- You can request or prefer to allocate out of such memory types by adding
+  `VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD` to VmaAllocationCreateInfo::requiredFlags
+  or VmaAllocationCreateInfo::preferredFlags. Those flags can be freely mixed with
+  other ways of \ref choosing_memory_type, like setting VmaAllocationCreateInfo::usage.
+- If you manually found memory type index to use for this purpose, force allocation
+  from this specific index by setting VmaAllocationCreateInfo::memoryTypeBits `= 1u << index`.
+
+\section vk_amd_device_coherent_memory_more_information More information
+
+To learn more about this extension, see [VK_AMD_device_coherent_memory in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_device_coherent_memory.html)
+
+Example use of this extension can be found in the code of the sample and test suite
+accompanying this library.
+
+
+\page enabling_buffer_device_address Enabling buffer device address
+
+Device extension VK_KHR_buffer_device_address
+allow to fetch raw GPU pointer to a buffer and pass it for usage in a shader code.
+It has been promoted to core Vulkan 1.2.
+
+If you want to use this feature in connection with VMA, follow these steps:
+
+\section enabling_buffer_device_address_initialization Initialization
+
+1) (For Vulkan version < 1.2) Call `vkEnumerateDeviceExtensionProperties` for the physical device.
+Check if the extension is supported - if returned array of `VkExtensionProperties` contains
+"VK_KHR_buffer_device_address".
+
+2) Call `vkGetPhysicalDeviceFeatures2` for the physical device instead of old `vkGetPhysicalDeviceFeatures`.
+Attach additional structure `VkPhysicalDeviceBufferDeviceAddressFeatures*` to `VkPhysicalDeviceFeatures2::pNext` to be returned.
+Check if the device feature is really supported - check if `VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress` is true.
+
+3) (For Vulkan version < 1.2) While creating device with `vkCreateDevice`, enable this extension - add
+"VK_KHR_buffer_device_address" to the list passed as `VkDeviceCreateInfo::ppEnabledExtensionNames`.
+
+4) While creating the device, also don't set `VkDeviceCreateInfo::pEnabledFeatures`.
+Fill in `VkPhysicalDeviceFeatures2` structure instead and pass it as `VkDeviceCreateInfo::pNext`.
+Enable this device feature - attach additional structure `VkPhysicalDeviceBufferDeviceAddressFeatures*` to
+`VkPhysicalDeviceFeatures2::pNext` and set its member `bufferDeviceAddress` to `VK_TRUE`.
+
+5) While creating #VmaAllocator with vmaCreateAllocator() inform VMA that you
+have enabled this feature - add #VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT
+to VmaAllocatorCreateInfo::flags.
+
+\section enabling_buffer_device_address_usage Usage
+
+After following steps described above, you can create buffers with `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT*` using VMA.
+The library automatically adds `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT*` to
+allocated memory blocks wherever it might be needed.
+
+Please note that the library supports only `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT*`.
+The second part of this functionality related to "capture and replay" is not supported,
+as it is intended for usage in debugging tools like RenderDoc, not in everyday Vulkan usage.
+
+\section enabling_buffer_device_address_more_information More information
+
+To learn more about this extension, see [VK_KHR_buffer_device_address in Vulkan specification](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/chap46.html#VK_KHR_buffer_device_address)
+
+Example use of this extension can be found in the code of the sample and test suite
+accompanying this library.
+
+\page general_considerations General considerations
+
+\section general_considerations_thread_safety Thread safety
+
+- The library has no global state, so separate #VmaAllocator objects can be used
+  independently.
+  There should be no need to create multiple such objects though - one per `VkDevice` is enough.
+- By default, all calls to functions that take #VmaAllocator as first parameter
+  are safe to call from multiple threads simultaneously because they are
+  synchronized internally when needed.
+  This includes allocation and deallocation from default memory pool, as well as custom #VmaPool.
+- When the allocator is created with #VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
+  flag, calls to functions that take such #VmaAllocator object must be
+  synchronized externally.
+- Access to a #VmaAllocation object must be externally synchronized. For example,
+  you must not call vmaGetAllocationInfo() and vmaMapMemory() from different
+  threads at the same time if you pass the same #VmaAllocation object to these
+  functions.
+- #VmaVirtualBlock is not safe to be used from multiple threads simultaneously.
+
+\section general_considerations_versioning_and_compatibility Versioning and compatibility
+
+The library uses [**Semantic Versioning**](https://semver.org/),
+which means version numbers follow convention: Major.Minor.Patch (e.g. 2.3.0), where:
+
+- Incremented Patch version means a release is backward- and forward-compatible,
+  introducing only some internal improvements, bug fixes, optimizations etc.
+  or changes that are out of scope of the official API described in this documentation.
+- Incremented Minor version means a release is backward-compatible,
+  so existing code that uses the library should continue to work, while some new
+  symbols could have been added: new structures, functions, new values in existing
+  enums and bit flags, new structure members, but not new function parameters.
+- Incrementing Major version means a release could break some backward compatibility.
+
+All changes between official releases are documented in file "CHANGELOG.md".
+
+\warning Backward compatiblity is considered on the level of C++ source code, not binary linkage.
+Adding new members to existing structures is treated as backward compatible if initializing
+the new members to binary zero results in the old behavior.
+You should always fully initialize all library structures to zeros and not rely on their
+exact binary size.
+
+\section general_considerations_validation_layer_warnings Validation layer warnings
+
+When using this library, you can meet following types of warnings issued by
+Vulkan validation layer. They don't necessarily indicate a bug, so you may need
+to just ignore them.
+
+- *vkBindBufferMemory(): Binding memory to buffer 0xeb8e4 but vkGetBufferMemoryRequirements() has not been called on that buffer.*
+  - It happens when VK_KHR_dedicated_allocation extension is enabled.
+    `vkGetBufferMemoryRequirements2KHR` function is used instead, while validation layer seems to be unaware of it.
+- *Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.*
+  - It happens when you map a buffer or image, because the library maps entire
+    `VkDeviceMemory` block, where different types of images and buffers may end
+    up together, especially on GPUs with unified memory like Intel.
+- *Non-linear image 0xebc91 is aliased with linear buffer 0xeb8e4 which may indicate a bug.*
+  - It may happen when you use [defragmentation](@ref defragmentation).
+
+\section general_considerations_allocation_algorithm Allocation algorithm
+
+The library uses following algorithm for allocation, in order:
+
+-# Try to find free range of memory in existing blocks.
+-# If failed, try to create a new block of `VkDeviceMemory`, with preferred block size.
+-# If failed, try to create such block with size / 2, size / 4, size / 8.
+-# If failed, try to allocate separate `VkDeviceMemory` for this allocation,
+   just like when you use #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
+-# If failed, choose other memory type that meets the requirements specified in
+   VmaAllocationCreateInfo and go to point 1.
+-# If failed, return `VK_ERROR_OUT_OF_DEVICE_MEMORY`.
+
+\section general_considerations_features_not_supported Features not supported
+
+Features deliberately excluded from the scope of this library:
+
+-# **Data transfer.** Uploading (streaming) and downloading data of buffers and images
+   between CPU and GPU memory and related synchronization is responsibility of the user.
+   Defining some "texture" object that would automatically stream its data from a
+   staging copy in CPU memory to GPU memory would rather be a feature of another,
+   higher-level library implemented on top of VMA.
+   VMA doesn't record any commands to a `VkCommandBuffer`. It just allocates memory.
+-# **Recreation of buffers and images.** Although the library has functions for
+   buffer and image creation: vmaCreateBuffer(), vmaCreateImage(), you need to
+   recreate these objects yourself after defragmentation. That is because the big
+   structures `VkBufferCreateInfo`, `VkImageCreateInfo` are not stored in
+   #VmaAllocation object.
+-# **Handling CPU memory allocation failures.** When dynamically creating small C++
+   objects in CPU memory (not Vulkan memory), allocation failures are not checked
+   and handled gracefully, because that would complicate code significantly and
+   is usually not needed in desktop PC applications anyway.
+   Success of an allocation is just checked with an assert.
+-# **Code free of any compiler warnings.** Maintaining the library to compile and
+   work correctly on so many different platforms is hard enough. Being free of
+   any warnings, on any version of any compiler, is simply not feasible.
+   There are many preprocessor macros that make some variables unused, function parameters unreferenced,
+   or conditional expressions constant in some configurations.
+   The code of this library should not be bigger or more complicated just to silence these warnings.
+   It is recommended to disable such warnings instead.
+-# This is a C++ library with C interface. **Bindings or ports to any other programming languages** are welcome as external projects but
+   are not going to be included into this repository.
+*/
diff --git a/3rdparty/vkmemalloc/vkmemalloc.cmake b/3rdparty/vkmemalloc/vkmemalloc.cmake
new file mode 100644
index 00000000000..0f318c3c542
--- /dev/null
+++ b/3rdparty/vkmemalloc/vkmemalloc.cmake
@@ -0,0 +1,38 @@
+include(ExternalProject)
+
+set(VMA_SOURCE_DIR "${OPEN3D_THIRD_PARTY_DOWNLOAD_DIR}/vkmemalloc")
+
+ExternalProject_Add(
+    ext_vkmemalloc
+    PREFIX vkmemalloc
+    URL https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/raw/refs/tags/v3.3.0/include/vk_mem_alloc.h
+    URL_HASH SHA256=90ce12fc4a2466235a09ae02905dd0c13aee80c1bbf11b331ab61230c2ceb112
+    DOWNLOAD_NAME vk_mem_alloc.h
+    DOWNLOAD_NO_EXTRACT TRUE
+    SOURCE_DIR "${VMA_SOURCE_DIR}"
+    DOWNLOAD_DIR "${OPEN3D_THIRD_PARTY_DOWNLOAD_DIR}/vkmemalloc"
+    UPDATE_COMMAND ""
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+)
+
+# VulkanMemoryAllocator-Hpp: C++ bindings for VMA (header-only, CC0 license).
+# Provides vma::functionsFromDispatcher() and vma::raii:: RAII wrappers.
+# Pinned to v3.3.0+3, matching the VMA C header above.
+set(VMA_HPP_SOURCE_DIR "${OPEN3D_THIRD_PARTY_DOWNLOAD_DIR}/vkmemalloc_hpp")
+ExternalProject_Add(
+    ext_vmahpp
+    PREFIX vkmemalloc_hpp
+    URL https://github.com/YaaZ/VulkanMemoryAllocator-Hpp/releases/download/v3.3.0%2B3/VulkanMemoryAllocator-Hpp-3.3.0.tar.gz
+    URL_HASH SHA256=8c2a0573babe1f86f3241d12b4c9df40bb944649b7f4239c1c611797f8af6cd5
+    DOWNLOAD_DIR "${OPEN3D_THIRD_PARTY_DOWNLOAD_DIR}/vkmemalloc_hpp"
+    SOURCE_DIR "${VMA_HPP_SOURCE_DIR}/src"
+    UPDATE_COMMAND ""
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS ext_vkmemalloc
+)
+
+set(VMA_INCLUDE_DIRS ${VMA_SOURCE_DIR}/ ${VMA_HPP_SOURCE_DIR}/src/) # "/" is critical.
\ No newline at end of file
diff --git a/3rdparty/vulkan_headers/vulkan_headers.cmake b/3rdparty/vulkan_headers/vulkan_headers.cmake
new file mode 100644
index 00000000000..bca1352e5be
--- /dev/null
+++ b/3rdparty/vulkan_headers/vulkan_headers.cmake
@@ -0,0 +1,16 @@
+include(ExternalProject)
+
+ExternalProject_Add(
+    ext_vulkan_headers
+    PREFIX vulkan_headers
+    URL https://github.com/KhronosGroup/Vulkan-Headers/archive/refs/tags/v1.4.349.tar.gz
+    URL_HASH SHA256=d7b84712f8469657baa37a436d1a23efbf0a6354fc8835b6758ef036e15dcc14
+    DOWNLOAD_DIR "${OPEN3D_THIRD_PARTY_DOWNLOAD_DIR}/vulkan_headers"
+    UPDATE_COMMAND ""
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+)
+
+ExternalProject_Get_Property(ext_vulkan_headers SOURCE_DIR)
+set(VULKAN_HEADERS_INCLUDE_DIRS ${SOURCE_DIR}/include/) # "/" is critical.
\ No newline at end of file
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000000..2d54639d388
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,92 @@
+Open3D is a cross-platform (Windows, Linux, macOS and x86_64, arm64, CUDA and
+oneAPI platforms) C++17 and Python library for 3D data processing,
+visualization, reconstruction, registration, and ML-related workflows. Other
+functionality is out of scope.
+
+## Coding and PR review directions
+
+- For any change, first research existing code and prepare a plan with definite goal, requirements, implementation steps, test method, risks and mitigations. **Lock the goal, requirements and test method, and keep the implementation steps with a log of status and decisions made.** Add plan summary to the PR description. 
+- Store intermediate live research and progress reports with important findings in .md files and refer to them as needed.
+- Use subagents for major steps. 
+- Create new git branches when you explore implementation options - go back to previous code as required. 
+- Prioritize human readability and maintainability.
+- **AVOID REDUNDANT IMPLEMENTATION** when similar functionality already exists - refactor and reuse instead.
+- Keep changes focused and small. Avoid broad refactors unless requested.
+- Read the relevant C++ / Python / docs files together and identify whether bindings, docs, and tests must change with the source change.
+- **Debugging:** Test root cause hypothesis with logging before trying fixes. Validate with logging afterwards. Undo failed fixes.
+- Developer docs: Document the code with brief comments (Why and What is the code doing?), typically for each function and file. Ensure code and docs are consistent.
+- User docs: Update `docs`, Doxygen docs in C++ headers and Google Sphinx RST docs in Python bindings for new / changed code behavior.  Add / update an example function use snippet in the docs.
+- For new functionality, docs and examples, prefer Tensor implementations that work on CPU+CUDA+SYCL. 
+- Use the Eigen library for Math operations and oneAPI TBB for multithreading. Avoid: OpenMP, stdgpu.
+- Add unit tests for new behavior and bug fixes (if needed).  Add or update both C++ and Python tests when the feature is exposed in both layers.
+- Keep dependencies minimal. Reuse functionality from existing dependencies if needed. Do not update 3rdparty code with patches.
+- Preserve existing public APIs unless the task explicitly requires API changes.
+- Avoid unnecessary compiler warnings, build breakages, and unrelated cleanup.
+- Ensure smallest set of relevant tests run correctly locally. The full CI must pass for all supported SW and HW platforms in Github.
+
+## Repository map
+
+- Core algorithms/data structures: `cpp/open3d/` 
+- New CPU+CUDA+SYCL (Tensor based) implementations: `cpp/open3d/{core,t}`
+- Legacy CPU only (Eigen based) data structures and algorithms: `cpp/open3d/{camera,geometry,io,pipelines}`
+- GUI visualization (based on GLFW + Dear ImGUI + Filament renderer): `cpp/open3d/visualization/{app,gui,rendering,visualizer}`
+- Legacy OpenGL + GLFW visualization: `cpp/open3d/visualization/visualizer`
+- C++ tests: `cpp/tests/`
+- Python bindings: `cpp/pybind/`
+- Python tests: `python/test/`
+- Examples: `examples/`
+- Build logic: `CMakeLists.txt`, `3rdparty/find_dependencies.txt`
+- Tooling/style/CI helpers: `util/`
+- Docs: `docs/` and inline docs in C++ headers (Doxygen) and Python bindings.
+
+## Build
+
+- `mkdir -p build && cd build`
+- Configure: `cmake -S .. -B . -D OPTION=VALUE...`
+- Build: `cmake --build . --parallel $NPROC --target TARGET` (NPROC = numn CPUs) 
+- Install: `cmake --build . --target install`
+
+If Python bindings are required, use an activated virtual environment or set
+`-DPython3_ROOT=/path/to/python`.  
+
+### Useful CMake options (specify `=ON` or `=OFF`):
+
+- `BUILD_UNIT_TESTS`
+- `BUILD_PYTHON_MODULE`
+- `BUILD_[CUDA|SYCL|ISPC]_MODULE`
+- `BUILD_EXAMPLES`
+- `BUILD_SHARED_LIBS`
+
+### Useful targets:
+- Python package targets: `python-package|pip-package|install-pip-package`
+- C++ tests: `tests`
+- C++ Binary library package: `package`
+- Viewer: `Open3DViewer`
+- Examples: By example name.
+
+## Test
+
+### C++
+
+- `./bin/tests --gtest_list_tests`
+- `./bin/tests --gtest_filter=*TEST_NAME*`
+
+### Python
+
+- `pip install -r python/requirements_test.txt`
+- `cmake --build build --target install-pip-package`
+- `pytest ../python/test/SPECIFIC/TEST_FILE.PY`
+
+## Style and formatting
+
+- C++ follows Google-style conventions with Open3D-specific rules.
+- Use 4 spaces, no tabs.
+- Use `#pragma once` for header guards.
+- Prefer smart pointers over naked pointers.
+- Use C++17, not C++20+.
+- Python follows Google Python style.
+
+Use the repository's own formatting tools and pinned versions.
+
+- `pip install -r python/requirements_style.txt`
+- `python util/check_style.py --apply` or `cmake --build build --target apply-style --parallel`
\ No newline at end of file
diff --git a/cmake/Open3DAddComputeShaders.cmake b/cmake/Open3DAddComputeShaders.cmake
new file mode 100644
index 00000000000..ae10eb1868d
--- /dev/null
+++ b/cmake/Open3DAddComputeShaders.cmake
@@ -0,0 +1,144 @@
+# Capture the directory of this file at include-time.  CMAKE_CURRENT_LIST_DIR
+# inside a function resolves to the caller's directory, not this file's directory,
+# so we must snapshot it here at file scope before the function definition.
+set(_Open3DAddComputeShaders_DIR "${CMAKE_CURRENT_LIST_DIR}" CACHE INTERNAL "")
+
+# open3d_add_compute_shaders(<target>
+#    OUTPUT_DIRECTORY <dir>
+#    SOURCES <shader1> [<shader2>...]
+# )
+#
+# For each standalone Vulkan GLSL compute shader source, this function:
+# - stages the original .comp file into <dir>
+# - compiles it to SPIR-V (.spv) with glslangValidator
+# - [on Apple] transpiles the SPIR-V to Metal Shading Language (.metal) with spirv-cross
+# On Apple, the .metal files are bundled into a single .metallib file for runtime loading
+# (newLibraryWithFile / newLibraryWithData), avoiding newLibraryWithSource.
+function(open3d_add_compute_shaders target)
+    cmake_parse_arguments(PARSE_ARGV 1 ARG "" "OUTPUT_DIRECTORY" "SOURCES")
+
+    if (ARG_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unknown arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if (ARG_KEYWORDS_MISSING_VALUES)
+        message(FATAL_ERROR "Missing values for arguments: ${ARG_KEYWORDS_MISSING_VALUES}")
+    endif()
+
+    if (NOT ARG_OUTPUT_DIRECTORY)
+        message(FATAL_ERROR "No output directory for compute shaders specified.")
+    endif()
+
+    if (NOT ARG_SOURCES)
+        message(FATAL_ERROR "No compute shader files specified.")
+    endif()
+
+    get_filename_component(OUTPUT_DIRECTORY_FULL_PATH "${ARG_OUTPUT_DIRECTORY}" ABSOLUTE)
+    file(MAKE_DIRECTORY ${OUTPUT_DIRECTORY_FULL_PATH})
+
+    find_program(OPEN3D_GLSLANG_VALIDATOR glslangValidator REQUIRED)
+    if (APPLE)
+        find_program(OPEN3D_SPIRV_CROSS spirv-cross REQUIRED)
+        # The scatter pass uses subgroup arithmetic (gl_SubgroupSize, subgroupAdd, etc.).
+        # Fixing the subgroup size to 32 (Apple Silicon SIMD width) lets the Metal compiler
+        # treat gl_SubgroupSize as a compile-time constant for loop unrolling.
+        set(SPIRV_CROSS_EXTRA_FLAGS_gaussian_radix_sort_scatter        "--msl-fixed-subgroup-size 32")
+        set(GAUSSIAN_METAL_BASENAMES "")
+    endif()
+
+    # Default glslangValidator flags: Vulkan 1.3 SPIR-V + LTO.
+    # Subgroup operations (gl_SubgroupSize, subgroupAdd, etc.) require Vulkan
+    # SPIR-V (-V) because glslangValidator's OpenGL target (-G) does not support
+    # them.  Most compute shaders use subgroup ops and therefore need -V.
+    set(GLSLANG_FLAGS -V --target-env vulkan1.3 -gVS)
+
+    foreach(shader IN LISTS ARG_SOURCES)
+        get_filename_component(SHADER_FULL_PATH "${shader}" ABSOLUTE)
+        get_filename_component(SHADER_NAME "${shader}" NAME)
+        get_filename_component(SHADER_BASENAME "${shader}" NAME_WE)
+        set(STAGED_SHADER_FULL_PATH "${OUTPUT_DIRECTORY_FULL_PATH}/${SHADER_NAME}")
+        set(STAGED_SPIRV_FULL_PATH "${OUTPUT_DIRECTORY_FULL_PATH}/${SHADER_BASENAME}.spv")
+        set(STAGED_METAL_FULL_PATH "${OUTPUT_DIRECTORY_FULL_PATH}/${SHADER_BASENAME}.metal")
+
+        file(RELATIVE_PATH STAGED_SHADER_RELATIVE_PATH
+            "${CMAKE_CURRENT_BINARY_DIR}" "${STAGED_SHADER_FULL_PATH}")
+        file(RELATIVE_PATH STAGED_SPIRV_RELATIVE_PATH
+            "${CMAKE_CURRENT_BINARY_DIR}" "${STAGED_SPIRV_FULL_PATH}")
+        file(RELATIVE_PATH STAGED_METAL_RELATIVE_PATH
+            "${CMAKE_CURRENT_BINARY_DIR}" "${STAGED_METAL_FULL_PATH}")
+
+        add_custom_command(
+            OUTPUT ${STAGED_SHADER_FULL_PATH} ${STAGED_SPIRV_FULL_PATH}
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                    ${SHADER_FULL_PATH} ${STAGED_SHADER_FULL_PATH}
+            COMMAND ${OPEN3D_GLSLANG_VALIDATOR}
+                    ${GLSLANG_FLAGS}
+                    ${SHADER_FULL_PATH} -o ${STAGED_SPIRV_FULL_PATH}
+            COMMENT "Compiling compute shader ${SHADER_NAME} to SPIR-V"
+            MAIN_DEPENDENCY ${shader}
+            VERBATIM
+        )
+        if (APPLE)
+            set(SPIRV_CROSS_EXTRA_FLAGS ${SPIRV_CROSS_EXTRA_FLAGS_${SHADER_BASENAME}})
+            file(GENERATE OUTPUT run_spirv_cross_${SHADER_BASENAME}.sh CONTENT 
+            "${OPEN3D_SPIRV_CROSS} \"${STAGED_SPIRV_FULL_PATH}\" --msl --msl-version 20400 --msl-decoration-binding ${SPIRV_CROSS_EXTRA_FLAGS} \
+            --rename-entry-point main ${SHADER_BASENAME}_main comp --output \"${STAGED_METAL_FULL_PATH}\" 
+            sed -i '' 's/#include <metal_stdlib>/#include <metal_stdlib>\\n#include <metal_simdgroup>/g' \"${STAGED_METAL_FULL_PATH}\"")
+            add_custom_command(
+                OUTPUT ${STAGED_METAL_FULL_PATH}
+                COMMAND sh run_spirv_cross_${SHADER_BASENAME}.sh
+                DEPENDS ${STAGED_SPIRV_FULL_PATH} run_spirv_cross_${SHADER_BASENAME}.sh
+                COMMENT "Transpiling compute shader ${SHADER_NAME} to Metal Shading Language and adding <metal_simdgroup>"
+                VERBATIM
+            )
+            list(APPEND GAUSSIAN_METAL_BASENAMES "${SHADER_BASENAME}")
+        endif()
+
+        list(APPEND STAGED_COMPUTE_SHADERS
+            "${STAGED_SHADER_FULL_PATH}"
+            "${STAGED_SPIRV_FULL_PATH}")
+        if (APPLE)
+            list(APPEND STAGED_COMPUTE_SHADERS "${STAGED_METAL_FULL_PATH}")
+        endif()
+    endforeach()
+
+    # Bundle SPIRV-Cross MSL into a single Metal library for runtime loading
+    # (newLibraryWithFile / newLibraryWithData), avoiding newLibraryWithSource.
+    if(APPLE AND GAUSSIAN_METAL_BASENAMES)
+        set(METALLIB_OUTPUT "${OUTPUT_DIRECTORY_FULL_PATH}/gaussian_splat.metallib")
+        set(METAL_AIR_FILES "")
+        foreach(BASE IN LISTS GAUSSIAN_METAL_BASENAMES)
+            set(STAGED_METAL_FULL_PATH "${OUTPUT_DIRECTORY_FULL_PATH}/${BASE}.metal")
+            set(STAGED_AIR_FULL_PATH "${OUTPUT_DIRECTORY_FULL_PATH}/${BASE}.air")
+            list(APPEND METAL_AIR_FILES "${STAGED_AIR_FULL_PATH}")
+            add_custom_command(
+                OUTPUT ${STAGED_AIR_FULL_PATH}
+                COMMAND xcrun -sdk macosx metal
+                        -std=macos-metal2.4
+                        -Wno-sometimes-uninitialized
+                        -c ${STAGED_METAL_FULL_PATH}
+                        -o ${STAGED_AIR_FULL_PATH}
+                DEPENDS ${STAGED_METAL_FULL_PATH}
+                COMMENT "Metal AIR: ${BASE}.metal"
+                VERBATIM
+            )
+        endforeach()
+        # In Xcode 16+, the standalone 'metallib' tool was removed; the 'metal'
+        # compiler now handles AIR -> metallib linking directly.
+        add_custom_command(
+            OUTPUT ${METALLIB_OUTPUT}
+            COMMAND xcrun -sdk macosx metal ${METAL_AIR_FILES} -o ${METALLIB_OUTPUT}
+            DEPENDS ${METAL_AIR_FILES}
+            COMMENT "Linking gaussian_splat.metallib"
+            VERBATIM
+        )
+        list(APPEND STAGED_COMPUTE_SHADERS "${METALLIB_OUTPUT}")
+    endif()
+
+    add_custom_target(${target} ALL
+        DEPENDS ${STAGED_COMPUTE_SHADERS}
+    )
+
+    set_target_properties(${target} PROPERTIES
+        COMPUTE_SHADER_FILES "${STAGED_COMPUTE_SHADERS}")
+endfunction()
\ No newline at end of file
diff --git a/cpp/apps/Open3DViewer/Open3DViewer_mac.mm b/cpp/apps/Open3DViewer/Open3DViewer_mac.mm
index 9e40dd80c3c..5f08df9f972 100644
--- a/cpp/apps/Open3DViewer/Open3DViewer_mac.mm
+++ b/cpp/apps/Open3DViewer/Open3DViewer_mac.mm
@@ -27,6 +27,7 @@
 
 class Open3DVisualizer : public open3d::visualization::GuiVisualizer {
     using Super = GuiVisualizer;
+
 public:
     Open3DVisualizer()
         : open3d::visualization::GuiVisualizer("Open3D", WIDTH, HEIGHT) {
@@ -49,55 +50,62 @@ void OnMenuItemSelected(Menu::ItemId item_id) override {
                 // This will set the users personal default to use Open3D for
                 // the file types below. THIS SHOULD ONLY BE CALLED
                 // AFTER THE USER EXPLICITLY CONFIRMS THAT THEY WANT TO DO THIS!
-                CFStringRef open3dBundleId = (__bridge CFStringRef)@"com.isl-org.open3d.Open3D";
+                CFStringRef open3dBundleId =
+                        (__bridge CFStringRef) @"com.isl-org.open3d.Open3D";
                 // The UTIs should match what we declare in Info.plist
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.gl-transmission-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.gl-transmission-format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.gl-binary-transmission-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.gl-binary-transmission-"
+                                               @"format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.geometry-definition-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.geometry-definition-"
+                                               @"format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.object-file-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.object-file-format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.point-cloud-library-file",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.point-cloud-library-"
+                                               @"file",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.polygon-file-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.polygon-file-format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.3d-points-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.3d-points-format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.standard-tesselated-geometry-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.standard-tesselated-"
+                                               @"geometry-format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.xyz-points-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.xyz-points-format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.xyzn-points-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.xyzn-points-format",
+                        kLSRolesAll, open3dBundleId);
                 LSSetDefaultRoleHandlerForContentType(
-                    (__bridge CFStringRef)@"public.xyzrgb-points-format",
-                    kLSRolesAll, open3dBundleId);
+                        (__bridge CFStringRef) @"public.xyzrgb-points-format",
+                        kLSRolesAll, open3dBundleId);
 
                 this->CloseDialog();
             });
 
             auto vert = std::make_shared<Vert>(0, Margins(em));
             vert->AddChild(std::make_shared<Label>(
-                "This will make Open3D the default application for the "
-                "following file types:"));
+                    "This will make Open3D the default application for the "
+                    "following file types:"));
             vert->AddFixed(em);
             auto table = std::make_shared<VGrid>(2, 0, Margins(em, 0, 0, 0));
             table->AddChild(std::make_shared<Label>("Mesh:"));
-            table->AddChild(std::make_shared<Label>(".gltf, .glb, .obj, .off, .ply, .stl"));
+            table->AddChild(std::make_shared<Label>(
+                    ".gltf, .glb, .obj, .off, .ply, .stl"));
             table->AddChild(std::make_shared<Label>("Point clouds:"));
-            table->AddChild(std::make_shared<Label>(".pcd, .ply, .pts, .xyz, .xyzn, .xyzrgb"));
+            table->AddChild(std::make_shared<Label>(
+                    ".pcd, .ply, .pts, .xyz, .xyzn, .xyzrgb"));
             vert->AddChild(table);
             vert->AddFixed(em);
             auto buttons = std::make_shared<Horiz>(0.5 * em);
@@ -129,11 +137,10 @@ static void LoadAndCreateWindow(const char *path) {
 @interface AppDelegate : NSObject <NSApplicationDelegate>
 @end
 
-@interface AppDelegate ()
-{
+@interface AppDelegate () {
     bool open_empty_window_;
 }
-@property (retain) NSTimer *timer;
+@property(retain) NSTimer *timer;
 @end
 
 @implementation AppDelegate
@@ -211,4 +218,4 @@ int main(int argc, const char *argv[]) {
     // ----
 }
 
-#endif // __APPLE__
+#endif  // __APPLE__
diff --git a/cpp/open3d/CMakeLists.txt b/cpp/open3d/CMakeLists.txt
index f2f5f8a9a05..0841c61403a 100644
--- a/cpp/open3d/CMakeLists.txt
+++ b/cpp/open3d/CMakeLists.txt
@@ -136,6 +136,20 @@ open3d_set_global_properties(Open3D)
 open3d_set_open3d_lib_properties(Open3D)
 open3d_link_3rdparty_libraries(Open3D)
 
+# GLX (X11) and EGL (Wayland) are needed by the OpenGL compute backend for
+# Gaussian splatting.  The context class detects the display server at runtime
+# and uses GLX on X11, EGL on Wayland.
+if (NOT APPLE)
+    find_package(OpenGL COMPONENTS EGL)
+    if (OpenGL_EGL_FOUND)
+        target_link_libraries(Open3D PRIVATE OpenGL::EGL)
+    endif()
+    find_package(X11 QUIET)
+    if (X11_FOUND)
+        target_link_libraries(Open3D PRIVATE X11::X11)
+    endif()
+endif()
+
 
 # If we are building a STATIC_LIBRARY, hide symbols coming from 3rd party static
 # libraries that are not hidden during compilation. Don't propagate beyond
diff --git a/cpp/open3d/io/FileFormatIO.cpp b/cpp/open3d/io/FileFormatIO.cpp
index 89089978292..d17d77006c9 100644
--- a/cpp/open3d/io/FileFormatIO.cpp
+++ b/cpp/open3d/io/FileFormatIO.cpp
@@ -22,6 +22,7 @@ static std::map<std::string, FileGeometry (*)(const std::string&)> gExt2Func = {
         {"off", ReadFileGeometryTypeOFF},
         {"pcd", ReadFileGeometryTypePCD},
         {"ply", ReadFileGeometryTypePLY},
+        {"splat", ReadFileGeometryTypeSPLAT},
         {"pts", ReadFileGeometryTypePTS},
         {"stl", ReadFileGeometryTypeSTL},
         {"xyz", ReadFileGeometryTypeXYZ},
@@ -29,6 +30,10 @@ static std::map<std::string, FileGeometry (*)(const std::string&)> gExt2Func = {
         {"xyzrgb", ReadFileGeometryTypeXYZRGB},
 };
 
+FileGeometry ReadFileGeometryTypeSPLAT(const std::string&) {
+    return FileGeometry(CONTAINS_POINTS | CONTAINS_GAUSSIAN_SPLATS);
+}
+
 FileGeometry ReadFileGeometryType(const std::string& path) {
     auto ext = utility::filesystem::GetFileExtensionInLowerCase(path);
     auto it = gExt2Func.find(ext);
diff --git a/cpp/open3d/io/FileFormatIO.h b/cpp/open3d/io/FileFormatIO.h
index 0f3b9343be7..c0c2646173c 100644
--- a/cpp/open3d/io/FileFormatIO.h
+++ b/cpp/open3d/io/FileFormatIO.h
@@ -17,6 +17,7 @@ enum FileGeometry {
     CONTAINS_POINTS = (1 << 0),
     CONTAINS_LINES = (1 << 1),
     CONTAINS_TRIANGLES = (1 << 2),
+    CONTAINS_GAUSSIAN_SPLATS = (1 << 3),
 };
 
 /// Returns the kind of geometry that the file contains. This is a quick
@@ -30,6 +31,7 @@ FileGeometry ReadFileGeometryTypeFBX(const std::string& path);
 FileGeometry ReadFileGeometryTypeOFF(const std::string& path);
 FileGeometry ReadFileGeometryTypePCD(const std::string& path);
 FileGeometry ReadFileGeometryTypePLY(const std::string& path);
+FileGeometry ReadFileGeometryTypeSPLAT(const std::string& path);
 FileGeometry ReadFileGeometryTypePTS(const std::string& path);
 FileGeometry ReadFileGeometryTypeSTL(const std::string& path);
 FileGeometry ReadFileGeometryTypeXYZ(const std::string& path);
diff --git a/cpp/open3d/io/file_format/FilePLY.cpp b/cpp/open3d/io/file_format/FilePLY.cpp
index 0912daee285..a8632df7e0a 100644
--- a/cpp/open3d/io/file_format/FilePLY.cpp
+++ b/cpp/open3d/io/file_format/FilePLY.cpp
@@ -7,6 +7,10 @@
 
 #include <rply.h>
 
+#include <algorithm>
+#include <cctype>
+#include <set>
+
 #include "open3d/io/FileFormatIO.h"
 #include "open3d/io/LineSetIO.h"
 #include "open3d/io/PointCloudIO.h"
@@ -23,6 +27,67 @@ namespace io {
 /// @cond
 namespace {
 
+std::string ToLowerString(std::string value) {
+    std::transform(value.begin(), value.end(), value.begin(),
+                   [](unsigned char character) {
+                       return static_cast<char>(std::tolower(character));
+                   });
+    return value;
+}
+
+bool HasGaussianSplatProperties(p_ply ply_file) {
+    std::set<std::string> vertex_property_names;
+
+    p_ply_element element = ply_get_next_element(ply_file, nullptr);
+    while (element) {
+        const char *element_name = nullptr;
+        long element_size = 0;
+        ply_get_element_info(element, &element_name, &element_size);
+        if (element_name != nullptr &&
+            ToLowerString(element_name) == "vertex" && element_size > 0) {
+            p_ply_property property = ply_get_next_property(element, nullptr);
+            while (property) {
+                const char *property_name = nullptr;
+                e_ply_type type;
+                ply_get_property_info(property, &property_name, &type, NULL,
+                                      NULL);
+                if (property_name != nullptr) {
+                    vertex_property_names.insert(ToLowerString(property_name));
+                }
+                property = ply_get_next_property(element, property);
+            }
+            break;
+        }
+        element = ply_get_next_element(ply_file, element);
+    }
+
+    const std::vector<std::string> required_properties = {"x", "y", "z",
+                                                          "opacity"};
+    const bool has_required_properties =
+            std::all_of(required_properties.begin(), required_properties.end(),
+                        [&vertex_property_names](const std::string &name) {
+                            return vertex_property_names.count(name) > 0;
+                        });
+    const int scale_count = static_cast<int>(std::count_if(
+            vertex_property_names.begin(), vertex_property_names.end(),
+            [](const std::string &name) {
+                return name.rfind("scale_", 0) == 0;
+            }));
+    const int rot_count = static_cast<int>(std::count_if(
+            vertex_property_names.begin(), vertex_property_names.end(),
+            [](const std::string &name) {
+                return name.rfind("rot_", 0) == 0;
+            }));
+    const int f_dc_count = static_cast<int>(std::count_if(
+            vertex_property_names.begin(), vertex_property_names.end(),
+            [](const std::string &name) {
+                return name.rfind("f_dc_", 0) == 0;
+            }));
+
+    return has_required_properties && scale_count >= 3 && rot_count >= 4 &&
+           f_dc_count >= 3;
+}
+
 namespace ply_pointcloud_reader {
 
 struct PLYReaderState {
@@ -361,6 +426,7 @@ FileGeometry ReadFileGeometryTypePLY(const std::string &path) {
         ply_close(ply_file);
         return CONTENTS_UNKNOWN;
     }
+    const bool is_gaussian_splat = HasGaussianSplatProperties(ply_file);
 
     auto nVertices =
             ply_set_read_cb(ply_file, "vertex", "x", nullptr, nullptr, 0);
@@ -382,6 +448,10 @@ FileGeometry ReadFileGeometryTypePLY(const std::string &path) {
     } else if (nVertices > 0) {
         contents |= CONTAINS_POINTS;
     }
+    if (is_gaussian_splat) {
+        contents |= CONTAINS_GAUSSIAN_SPLATS;
+        contents |= CONTAINS_POINTS;
+    }
     return FileGeometry(contents);
 }
 
diff --git a/cpp/open3d/t/geometry/PointCloud.cpp b/cpp/open3d/t/geometry/PointCloud.cpp
index f199d4bdad4..87f1ae272e7 100644
--- a/cpp/open3d/t/geometry/PointCloud.cpp
+++ b/cpp/open3d/t/geometry/PointCloud.cpp
@@ -14,6 +14,7 @@
 #include <libqhullcpp/QhullVertexSet.h>
 
 #include <Eigen/Core>
+#include <Eigen/Geometry>
 #include <algorithm>
 #include <limits>
 #include <string>
@@ -45,19 +46,155 @@ namespace open3d {
 namespace t {
 namespace geometry {
 
-PointCloud::PointCloud(const core::Device &device)
+namespace {
+
+// ---------------------------------------------------------------------------
+// Ivanic–Ruedenberg (IR 1996/1998) real-SH rotation helpers.
+//
+// BuildIrR1   : degree-1 IR matrix — maps (y,z,x) SH ordering to the
+//               shader's EvaluateShDegree1 convention (m=-1→y, m=0→z, m=+1→x).
+// BuildIrRl   : degree l≥2 matrix via u,v,w recursion (Ivanic 1996 eq.).
+// RotateGSSplat: updates rot + f_rest for a GS PointCloud after Rotate().
+// ---------------------------------------------------------------------------
+
+Eigen::Matrix3f BuildIrR1(const Eigen::Matrix3f& R) {
+    // SH degree-1 basis index → Cartesian axis: {y=1, z=2, x=0}
+    constexpr int idx[3] = {1, 2, 0};
+    Eigen::Matrix3f R1;
+    for (int i = 0; i < 3; ++i)
+        for (int j = 0; j < 3; ++j) R1(i, j) = R(idx[i], idx[j]);
+    return R1;
+}
+
+Eigen::MatrixXf BuildIrRl(int l,
+                          const Eigen::Matrix3f& R1,
+                          const Eigen::MatrixXf& Rp) {
+    // Rp: IR matrix for degree l-1 (shape (2(l-1)+1) × (2(l-1)+1)).
+    auto P = [&](int i, int a, int b) {
+        auto g = [&](int m, int n) { return Rp(m + l - 1, n + l - 1); };
+        if (b == l)
+            return R1(i + 1, 2) * g(a, l - 1) - R1(i + 1, 0) * g(a, -(l - 1));
+        if (b == -l)
+            return R1(i + 1, 2) * g(a, -(l - 1)) + R1(i + 1, 0) * g(a, l - 1);
+        return R1(i + 1, 1) * g(a, b);
+    };
+
+    int s = 2 * l + 1;
+    Eigen::MatrixXf Rl = Eigen::MatrixXf::Zero(s, s);
+    for (int m = -l; m <= l; ++m) {
+        for (int n = -l; n <= l; ++n) {
+            float d = (m == 0) ? 1.f : 0.f;
+            float denom = std::abs(n) < l ? float(l * l - n * n)
+                                          : float(l * (2 * l - 1));
+            float am = std::abs(float(m));
+            float u = std::sqrt(float(l * l - m * m) / denom);
+            float v = 0.5f *
+                      std::sqrt((1.f + d) * (l + am - 1.f) * (l + am) / denom) *
+                      (1.f - 2.f * d);
+            float w = am > 0.f ? -0.5f * std::sqrt((l - am - 1.f) * (l - am) /
+                                                   denom)
+                               : 0.f;
+            float res = 0.f;
+            if (u != 0.f) res += u * P(0, m, n);
+            if (v != 0.f) res += v * P(1, m, n);
+            if (w != 0.f) res += w * P(-1, m, n);
+            Rl(m + l, n + l) = res;
+        }
+    }
+    return Rl;
+}
+
+// Update rot and f_rest in-place after Rotate(R, center).
+// Proper rotation is assumed (same policy as RotateNormalsKernel).
+// rot: CPU Eigen loop. f_rest: IR matrices computed on CPU, Matmul on device.
+void RotateGSSplat(const core::Tensor& R_tensor, PointCloud& pcd) {
+    auto device = pcd.GetDevice();
+    int64_t N = pcd.GetPointPositions().GetLength();
+
+    // Read R into Eigen (float32, row-major).
+    auto R_f32 = R_tensor.To(core::Device("CPU:0"), core::Float32).Contiguous();
+    const float* rp = R_f32.GetDataPtr<float>();
+    Eigen::Matrix3f R;
+    for (int i = 0; i < 3; ++i)
+        for (int j = 0; j < 3; ++j) R(i, j) = rp[i * 3 + j];
+
+    // --- Quaternion rotation (CPU only) ---
+    // q_new = Quaternion(R) * q_old per splat; improper R gives undefined
+    // results (same policy as normals not being renormalised for non-orthogonal
+    // R).
+    auto rot_attr = pcd.GetPointAttr("rot").To(core::Device("CPU:0"));
+    Eigen::Quaternionf qR(R);
+    float* rptr = rot_attr.GetDataPtr<float>();
+    for (int64_t n = 0; n < N; ++n) {
+        Eigen::Quaternionf q(rptr[n * 4 + 0], rptr[n * 4 + 1], rptr[n * 4 + 2],
+                             rptr[n * 4 + 3]);
+        Eigen::Quaternionf qn = qR * q;
+        rptr[n * 4 + 0] = qn.w();
+        rptr[n * 4 + 1] = qn.x();
+        rptr[n * 4 + 2] = qn.y();
+        rptr[n * 4 + 3] = qn.z();
+    }
+    if (!pcd.GetDevice().IsCPU()) {
+        pcd.SetPointAttr("rot", rot_attr.To(device));
+    }
+
+    // --- SH rotation (all devices via Tensor Matmul) ---
+    // f_dc (degree-0) is invariant; f_rest holds degrees 1 … sh_degree.
+    int sh_degree = pcd.GaussianSplatGetSHOrder();
+    if (sh_degree == 0) return;
+
+    auto& f_rest_attr = pcd.GetPointAttr("f_rest");
+    int64_t Nc = f_rest_attr.GetShape(1);  // (sh_degree+1)² − 1
+
+    // Build block-diagonal rotation matrix R_full (Nc×Nc) on CPU, then
+    // transpose it — we need R_full^T for the right-multiply: f @ R_full^T.
+    Eigen::MatrixXf R_full_T = Eigen::MatrixXf::Zero(Nc, Nc);
+    Eigen::Matrix3f R1 = BuildIrR1(R);
+    Eigen::MatrixXf Rp = R1;
+    int offset = 0;
+    for (int l = 1; l <= sh_degree; ++l) {
+        int sl = 2 * l + 1;
+        Eigen::MatrixXf Rl =
+                (l == 1) ? Eigen::MatrixXf(R1) : BuildIrRl(l, R1, Rp);
+        R_full_T.block(offset, offset, sl, sl) = Rl.transpose();
+        Rp = Rl;
+        offset += sl;
+    }
+
+    // Pack into a float32 Tensor and move to device.
+    std::vector<float> rft_data(Nc * Nc);
+    for (int r = 0; r < Nc; ++r)
+        for (int c = 0; c < Nc; ++c) rft_data[r * Nc + c] = R_full_T(r, c);
+    core::Tensor Rft(rft_data, {Nc, Nc}, core::Float32, core::Device("CPU:0"));
+    Rft = Rft.To(device, core::Float32);
+
+    // f_rest {N, Nc, 3} → permute {N, 3, Nc} → reshape {N*3, Nc}
+    //   @ Rft {Nc, Nc}  → {N*3, Nc} → reshape {N, 3, Nc} → permute {N, Nc, 3}
+    auto f_2d = f_rest_attr.To(core::Float32)
+                        .Permute({0, 2, 1})
+                        .Contiguous()
+                        .Reshape({N * 3, Nc});
+    f_rest_attr = f_2d.Matmul(Rft)
+                          .Reshape({N, 3, Nc})
+                          .Permute({0, 2, 1})
+                          .Contiguous();
+}
+
+}  // namespace
+
+PointCloud::PointCloud(const core::Device& device)
     : Geometry(Geometry::GeometryType::PointCloud, 3),
       device_(device),
       point_attr_(TensorMap("positions")) {}
 
-PointCloud::PointCloud(const core::Tensor &points)
+PointCloud::PointCloud(const core::Tensor& points)
     : PointCloud(points.GetDevice()) {
     core::AssertTensorShape(points, {std::nullopt, 3});
     SetPointPositions(points);
 }
 
-PointCloud::PointCloud(const std::unordered_map<std::string, core::Tensor>
-                               &map_keys_to_tensors)
+PointCloud::PointCloud(const std::unordered_map<std::string, core::Tensor>&
+                               map_keys_to_tensors)
     : Geometry(Geometry::GeometryType::PointCloud, 3),
       point_attr_(TensorMap("positions")) {
     if (map_keys_to_tensors.count("positions") == 0) {
@@ -85,7 +222,7 @@ std::string PointCloud::ToString() const {
     if ((point_attr_.size() - point_attr_.count(point_attr_.GetPrimaryKey())) ==
         0)
         return str + " None.";
-    for (const auto &keyval : point_attr_) {
+    for (const auto& keyval : point_attr_) {
         if (keyval.first != "positions") {
             str += fmt::format(" {} (dtype = {}, shape = {}),", keyval.first,
                                keyval.second.GetDtype().ToString(),
@@ -108,12 +245,12 @@ core::Tensor PointCloud::GetCenter() const {
     return GetPointPositions().Mean({0});
 }
 
-PointCloud PointCloud::To(const core::Device &device, bool copy) const {
+PointCloud PointCloud::To(const core::Device& device, bool copy) const {
     if (!copy && GetDevice() == device) {
         return *this;
     }
     PointCloud pcd(device);
-    for (auto &kv : point_attr_) {
+    for (auto& kv : point_attr_) {
         pcd.SetPointAttr(kv.first, kv.second.To(device, /*copy=*/true));
     }
     return pcd;
@@ -121,12 +258,12 @@ PointCloud PointCloud::To(const core::Device &device, bool copy) const {
 
 PointCloud PointCloud::Clone() const { return To(GetDevice(), /*copy=*/true); }
 
-PointCloud PointCloud::Append(const PointCloud &other) const {
+PointCloud PointCloud::Append(const PointCloud& other) const {
     PointCloud pcd(GetDevice());
 
     int64_t length = GetPointPositions().GetLength();
 
-    for (auto &kv : point_attr_) {
+    for (auto& kv : point_attr_) {
         if (other.HasPointAttr(kv.first)) {
             auto other_attr = other.GetPointAttr(kv.first);
             core::AssertTensorDtype(other_attr, kv.second.GetDtype());
@@ -167,7 +304,7 @@ PointCloud PointCloud::Append(const PointCloud &other) const {
     return pcd;
 }
 
-PointCloud &PointCloud::Transform(const core::Tensor &transformation) {
+PointCloud& PointCloud::Transform(const core::Tensor& transformation) {
     core::AssertTensorShape(transformation, {4, 4});
 
     kernel::transform::TransformPoints(transformation, GetPointPositions());
@@ -175,10 +312,20 @@ PointCloud &PointCloud::Transform(const core::Tensor &transformation) {
         kernel::transform::TransformNormals(transformation, GetPointNormals());
     }
 
+    // The linear part of a general 4×4 may be non-orthogonal, so covariance
+    // (rot, scale) and SH (f_rest) cannot be updated generically.
+    // Compose Rotate() + Scale() + Translate() instead for GS clouds.
+    if (IsGaussianSplat()) {
+        utility::LogWarning(
+                "PointCloud::Transform() does not update Gaussian splat "
+                "attributes (rot, scale, f_rest). Use Rotate(), Scale(), and "
+                "Translate() instead.");
+    }
+
     return *this;
 }
 
-PointCloud &PointCloud::Translate(const core::Tensor &translation,
+PointCloud& PointCloud::Translate(const core::Tensor& translation,
                                   bool relative) {
     core::AssertTensorShape(translation, {3});
 
@@ -192,30 +339,55 @@ PointCloud &PointCloud::Translate(const core::Tensor &translation,
     return *this;
 }
 
-PointCloud &PointCloud::Scale(double scale, const core::Tensor &center) {
+PointCloud& PointCloud::Scale(double scale, const core::Tensor& center) {
     core::AssertTensorShape(center, {3});
 
     const core::Tensor center_d =
             center.To(GetDevice(), GetPointPositions().GetDtype());
-
     GetPointPositions().Sub_(center_d).Mul_(scale).Add_(center_d);
+
+    // For GS splats, negative uniform scale means point inversion plus
+    // positive scaling: positions are mirrored (above), axis lengths scale by
+    // |scale|, and odd-degree SH bands flip sign because Y_lm(-d) = (-1)^l
+    // Y_lm(d).
+    if (IsGaussianSplat()) {
+        GetPointAttr("scale").Mul_(std::abs(scale));
+        if (scale < 0.0) {
+            int sh_degree = GaussianSplatGetSHOrder();
+            for (int l = 1; l <= sh_degree; l += 2) {
+                const int offset = l * l - 1;
+                const int size_l = 2 * l + 1;
+                GetPointAttr("f_rest")
+                        .Slice(1, offset, offset + size_l)
+                        .Mul_(-1.0);
+            }
+        }
+    }
+
     return *this;
 }
 
-PointCloud &PointCloud::Rotate(const core::Tensor &R,
-                               const core::Tensor &center) {
+PointCloud& PointCloud::Rotate(const core::Tensor& R,
+                               const core::Tensor& center) {
     core::AssertTensorShape(R, {3, 3});
     core::AssertTensorShape(center, {3});
 
     kernel::transform::RotatePoints(R, GetPointPositions(), center);
-
     if (HasPointNormals()) {
         kernel::transform::RotateNormals(R, GetPointNormals());
     }
+
+    // For GS splats: rotate quaternions (CPU) and SH coefficients (all
+    // devices). Proper rotation is assumed, consistent with RotateNormalsKernel
+    // which applies R directly without orthogonality checks.
+    if (IsGaussianSplat()) {
+        RotateGSSplat(R, *this);
+    }
+
     return *this;
 }
 
-PointCloud PointCloud::SelectByMask(const core::Tensor &boolean_mask,
+PointCloud PointCloud::SelectByMask(const core::Tensor& boolean_mask,
                                     bool invert /* = false */) const {
     const int64_t length = GetPointPositions().GetLength();
     core::AssertTensorDtype(boolean_mask, core::Dtype::Bool);
@@ -230,7 +402,7 @@ PointCloud PointCloud::SelectByMask(const core::Tensor &boolean_mask,
     }
 
     PointCloud pcd(GetDevice());
-    for (auto &kv : GetPointAttr()) {
+    for (auto& kv : GetPointAttr()) {
         if (HasPointAttr(kv.first)) {
             pcd.SetPointAttr(kv.first, kv.second.IndexGet({indices_local}));
         }
@@ -242,7 +414,7 @@ PointCloud PointCloud::SelectByMask(const core::Tensor &boolean_mask,
 }
 
 PointCloud PointCloud::SelectByIndex(
-        const core::Tensor &indices,
+        const core::Tensor& indices,
         bool invert /* = false */,
         bool remove_duplicates /* = false */) const {
     const int64_t length = GetPointPositions().GetLength();
@@ -253,7 +425,7 @@ PointCloud PointCloud::SelectByIndex(
 
     if (!remove_duplicates && !invert) {
         core::TensorKey key = core::TensorKey::IndexTensor(indices);
-        for (auto &kv : GetPointAttr()) {
+        for (auto& kv : GetPointAttr()) {
             if (HasPointAttr(kv.first)) {
                 pcd.SetPointAttr(kv.first, kv.second.GetItem(key));
             }
@@ -277,7 +449,7 @@ PointCloud PointCloud::SelectByIndex(
 }
 
 PointCloud PointCloud::VoxelDownSample(double voxel_size,
-                                       const std::string &reduction) const {
+                                       const std::string& reduction) const {
     if (voxel_size <= 0) {
         utility::LogError("voxel_size must be positive.");
     }
@@ -316,7 +488,7 @@ PointCloud PointCloud::VoxelDownSample(double voxel_size,
 
     // Create a new point cloud.
     PointCloud pcd_down(device_);
-    for (auto &kv : point_attr_) {
+    for (auto& kv : point_attr_) {
         auto point_attr = kv.second;
 
         std::string attr_string = kv.first;
@@ -350,7 +522,7 @@ PointCloud PointCloud::UniformDownSample(size_t every_k_points) const {
     const int64_t length = GetPointPositions().GetLength();
 
     PointCloud pcd_down(GetDevice());
-    for (auto &kv : GetPointAttr()) {
+    for (auto& kv : GetPointAttr()) {
         pcd_down.SetPointAttr(
                 kv.first,
                 kv.second.Slice(0, 0, length, (int64_t)every_k_points));
@@ -534,7 +706,7 @@ std::tuple<PointCloud, core::Tensor> PointCloud::RemoveDuplicatedPoints()
     return std::make_tuple(SelectByMask(masks), masks);
 }
 
-PointCloud &PointCloud::NormalizeNormals() {
+PointCloud& PointCloud::NormalizeNormals() {
     if (!HasPointNormals()) {
         utility::LogWarning("PointCloud has no normals.");
         return *this;
@@ -542,7 +714,7 @@ PointCloud &PointCloud::NormalizeNormals() {
         SetPointNormals(GetPointNormals().Contiguous());
     }
 
-    core::Tensor &normals = GetPointNormals();
+    core::Tensor& normals = GetPointNormals();
     if (IsCPU()) {
         kernel::pointcloud::NormalizeNormalsCPU(normals);
     } else if (IsCUDA()) {
@@ -554,7 +726,7 @@ PointCloud &PointCloud::NormalizeNormals() {
     return *this;
 }
 
-PointCloud &PointCloud::PaintUniformColor(const core::Tensor &color) {
+PointCloud& PointCloud::PaintUniformColor(const core::Tensor& color) {
     core::AssertTensorShape(color, {3});
     core::Tensor clipped_color = color.To(GetDevice());
     if (color.GetDtype() == core::Float32 ||
@@ -710,7 +882,7 @@ void PointCloud::EstimateNormals(
 }
 
 void PointCloud::OrientNormalsToAlignWithDirection(
-        const core::Tensor &orientation_reference) {
+        const core::Tensor& orientation_reference) {
     core::AssertTensorDevice(orientation_reference, GetDevice());
     core::AssertTensorShape(orientation_reference, {3});
 
@@ -724,7 +896,7 @@ void PointCloud::OrientNormalsToAlignWithDirection(
     core::Tensor reference =
             orientation_reference.To(GetPointPositions().GetDtype());
 
-    core::Tensor &normals = GetPointNormals();
+    core::Tensor& normals = GetPointNormals();
     if (IsCPU()) {
         kernel::pointcloud::OrientNormalsToAlignWithDirectionCPU(normals,
                                                                  reference);
@@ -737,7 +909,7 @@ void PointCloud::OrientNormalsToAlignWithDirection(
 }
 
 void PointCloud::OrientNormalsTowardsCameraLocation(
-        const core::Tensor &camera_location) {
+        const core::Tensor& camera_location) {
     core::AssertTensorDevice(camera_location, GetDevice());
     core::AssertTensorShape(camera_location, {3});
 
@@ -750,7 +922,7 @@ void PointCloud::OrientNormalsTowardsCameraLocation(
 
     core::Tensor reference = camera_location.To(GetPointPositions().GetDtype());
 
-    core::Tensor &normals = GetPointNormals();
+    core::Tensor& normals = GetPointNormals();
     if (IsCPU()) {
         kernel::pointcloud::OrientNormalsTowardsCameraLocationCPU(
                 GetPointPositions().Contiguous(), normals, reference);
@@ -868,10 +1040,10 @@ void PointCloud::EstimateColorGradients(
 }
 
 static PointCloud CreatePointCloudWithNormals(
-        const Image &depth_in, /* UInt16 or Float32 */
-        const Image &color_in, /* Float32 */
-        const core::Tensor &intrinsics_in,
-        const core::Tensor &extrinsics,
+        const Image& depth_in, /* UInt16 or Float32 */
+        const Image& color_in, /* Float32 */
+        const core::Tensor& intrinsics_in,
+        const core::Tensor& extrinsics,
         float depth_scale,
         float depth_max,
         int stride) {
@@ -951,9 +1123,9 @@ static PointCloud CreatePointCloudWithNormals(
     return pcd;
 }
 
-PointCloud PointCloud::CreateFromDepthImage(const Image &depth,
-                                            const core::Tensor &intrinsics,
-                                            const core::Tensor &extrinsics,
+PointCloud PointCloud::CreateFromDepthImage(const Image& depth,
+                                            const core::Tensor& intrinsics,
+                                            const core::Tensor& extrinsics,
                                             float depth_scale,
                                             float depth_max,
                                             int stride,
@@ -981,9 +1153,9 @@ PointCloud PointCloud::CreateFromDepthImage(const Image &depth,
     }
 }
 
-PointCloud PointCloud::CreateFromRGBDImage(const RGBDImage &rgbd_image,
-                                           const core::Tensor &intrinsics,
-                                           const core::Tensor &extrinsics,
+PointCloud PointCloud::CreateFromRGBDImage(const RGBDImage& rgbd_image,
+                                           const core::Tensor& intrinsics,
+                                           const core::Tensor& extrinsics,
                                            float depth_scale,
                                            float depth_max,
                                            int stride,
@@ -1010,8 +1182,8 @@ PointCloud PointCloud::CreateFromRGBDImage(const RGBDImage &rgbd_image,
 
 geometry::Image PointCloud::ProjectToDepthImage(int width,
                                                 int height,
-                                                const core::Tensor &intrinsics,
-                                                const core::Tensor &extrinsics,
+                                                const core::Tensor& intrinsics,
+                                                const core::Tensor& extrinsics,
                                                 float depth_scale,
                                                 float depth_max) {
     if (!HasPointPositions()) {
@@ -1034,8 +1206,8 @@ geometry::Image PointCloud::ProjectToDepthImage(int width,
 geometry::RGBDImage PointCloud::ProjectToRGBDImage(
         int width,
         int height,
-        const core::Tensor &intrinsics,
-        const core::Tensor &extrinsics,
+        const core::Tensor& intrinsics,
+        const core::Tensor& extrinsics,
         float depth_scale,
         float depth_max) {
     if (!HasPointPositions()) {
@@ -1070,9 +1242,9 @@ geometry::RGBDImage PointCloud::ProjectToRGBDImage(
 }
 
 PointCloud PointCloud::FromLegacy(
-        const open3d::geometry::PointCloud &pcd_legacy,
+        const open3d::geometry::PointCloud& pcd_legacy,
         core::Dtype dtype,
-        const core::Device &device) {
+        const core::Device& device) {
     geometry::PointCloud pcd(device);
     if (pcd_legacy.HasPoints()) {
         pcd.SetPointPositions(
@@ -1146,7 +1318,7 @@ open3d::geometry::PointCloud PointCloud::ToLegacy() const {
 }
 
 std::tuple<TriangleMesh, core::Tensor> PointCloud::HiddenPointRemoval(
-        const core::Tensor &camera_location, double radius) const {
+        const core::Tensor& camera_location, double radius) const {
     core::AssertTensorShape(camera_location, {3});
     core::AssertTensorDevice(camera_location, GetDevice());
 
@@ -1245,7 +1417,7 @@ TriangleMesh PointCloud::ComputeConvexHull(bool joggle_inputs) const {
             auto inserted = vertex_map.insert({vidx, next_vtx});
             if (inserted.second) {
                 p_triangle[triangle_subscript] = next_vtx;  // hull vertex idx
-                double *coords = p.coordinates();
+                double* coords = p.coordinates();
                 std::copy(coords, coords + 3, p_vertices);
                 p_vertices += 3;
                 p_point_indices[next_vtx++] = vidx;
@@ -1284,7 +1456,7 @@ OrientedBoundingBox PointCloud::GetOrientedBoundingBox() const {
 }
 
 LineSet PointCloud::ExtrudeRotation(double angle,
-                                    const core::Tensor &axis,
+                                    const core::Tensor& axis,
                                     int resolution,
                                     double translation,
                                     bool capping) const {
@@ -1293,14 +1465,14 @@ LineSet PointCloud::ExtrudeRotation(double angle,
                                   capping);
 }
 
-LineSet PointCloud::ExtrudeLinear(const core::Tensor &vector,
+LineSet PointCloud::ExtrudeLinear(const core::Tensor& vector,
                                   double scale,
                                   bool capping) const {
     using namespace vtkutils;
     return ExtrudeLinearLineSet(*this, vector, scale, capping);
 }
 
-PointCloud PointCloud::Crop(const AxisAlignedBoundingBox &aabb,
+PointCloud PointCloud::Crop(const AxisAlignedBoundingBox& aabb,
                             bool invert) const {
     core::AssertTensorDevice(GetPointPositions(), aabb.GetDevice());
     if (aabb.IsEmpty()) {
@@ -1314,7 +1486,7 @@ PointCloud PointCloud::Crop(const AxisAlignedBoundingBox &aabb,
             aabb.GetPointIndicesWithinBoundingBox(GetPointPositions()), invert);
 }
 
-PointCloud PointCloud::Crop(const OrientedBoundingBox &obb, bool invert) const {
+PointCloud PointCloud::Crop(const OrientedBoundingBox& obb, bool invert) const {
     core::AssertTensorDevice(GetPointPositions(), obb.GetDevice());
     if (obb.IsEmpty()) {
         utility::LogWarning(
@@ -1336,7 +1508,7 @@ int PointCloud::PCAPartition(int max_points) {
     return num_partitions;
 }
 
-core::Tensor PointCloud::ComputeMetrics(const PointCloud &pcd2,
+core::Tensor PointCloud::ComputeMetrics(const PointCloud& pcd2,
                                         std::vector<Metric> metrics,
                                         MetricParameters params) const {
     if (IsEmpty() || pcd2.IsEmpty()) {
@@ -1389,7 +1561,7 @@ int PointCloud::GaussianSplatGetSHOrder() const {
     if (point_attr_.find("f_rest") == point_attr_.end()) {
         return 0;
     }
-    const core::Tensor &f_rest = GetPointAttr("f_rest");
+    const core::Tensor& f_rest = GetPointAttr("f_rest");
     auto num_points = GetPointPositions().GetLength();
     core::AssertTensorShape(f_rest, {num_points, core::None, 3});
     auto Nc = f_rest.GetShape(1);
diff --git a/cpp/open3d/t/geometry/PointCloud.h b/cpp/open3d/t/geometry/PointCloud.h
index e762c37a09f..43fc7575ec9 100644
--- a/cpp/open3d/t/geometry/PointCloud.h
+++ b/cpp/open3d/t/geometry/PointCloud.h
@@ -83,7 +83,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// Construct an empty point cloud on the provided device.
     /// \param device The device on which to initialize the point cloud
     /// (default: 'CPU:0').
-    PointCloud(const core::Device &device = core::Device("CPU:0"));
+    PointCloud(const core::Device& device = core::Device("CPU:0"));
 
     /// Construct a point cloud from points.
     ///
@@ -91,15 +91,15 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// point cloud (no memory copy).
     ///
     /// \param points A tensor with element shape {3}.
-    PointCloud(const core::Tensor &points);
+    PointCloud(const core::Tensor& points);
 
     /// Construct from points and other attributes of the points.
     ///
     /// \param map_keys_to_tensors A map of string to Tensor containing
     /// points and their attributes. point_dict must contain at least the
     /// "positions" key.
-    PointCloud(const std::unordered_map<std::string, core::Tensor>
-                       &map_keys_to_tensors);
+    PointCloud(const std::unordered_map<std::string, core::Tensor>&
+                       map_keys_to_tensors);
 
     virtual ~PointCloud() override {}
 
@@ -107,46 +107,46 @@ class PointCloud : public Geometry, public DrawableGeometry {
     std::string ToString() const;
 
     /// Getter for point_attr_ TensorMap. Used in Pybind.
-    const TensorMap &GetPointAttr() const { return point_attr_; }
+    const TensorMap& GetPointAttr() const { return point_attr_; }
 
     /// Getter for point_attr_ TensorMap.
-    TensorMap &GetPointAttr() { return point_attr_; }
+    TensorMap& GetPointAttr() { return point_attr_; }
 
     /// Get attributes. Throws exception if the attribute does not exist.
     ///
     /// \param key Attribute name.
-    core::Tensor &GetPointAttr(const std::string &key) {
+    core::Tensor& GetPointAttr(const std::string& key) {
         return point_attr_.at(key);
     }
 
     /// Get the value of the "positions" attribute. Convenience function.
-    core::Tensor &GetPointPositions() { return GetPointAttr("positions"); }
+    core::Tensor& GetPointPositions() { return GetPointAttr("positions"); }
 
     /// Get the value of the "colors" attribute. Convenience function.
-    core::Tensor &GetPointColors() { return GetPointAttr("colors"); }
+    core::Tensor& GetPointColors() { return GetPointAttr("colors"); }
 
     /// Get the value of the "normals" attribute. Convenience function.
-    core::Tensor &GetPointNormals() { return GetPointAttr("normals"); }
+    core::Tensor& GetPointNormals() { return GetPointAttr("normals"); }
 
     /// Get attributes. Throws exception if the attribute does not exist.
     ///
     /// \param key Attribute name.
-    const core::Tensor &GetPointAttr(const std::string &key) const {
+    const core::Tensor& GetPointAttr(const std::string& key) const {
         return point_attr_.at(key);
     }
 
     /// Get the value of the "positions" attribute. Convenience function.
-    const core::Tensor &GetPointPositions() const {
+    const core::Tensor& GetPointPositions() const {
         return GetPointAttr("positions");
     }
 
     /// Get the value of the "colors" attribute. Convenience function.
-    const core::Tensor &GetPointColors() const {
+    const core::Tensor& GetPointColors() const {
         return GetPointAttr("colors");
     }
 
     /// Get the value of the "normals" attribute. Convenience function.
-    const core::Tensor &GetPointNormals() const {
+    const core::Tensor& GetPointNormals() const {
         return GetPointAttr("normals");
     }
 
@@ -155,7 +155,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     ///
     /// \param key Attribute name.
     /// \param value A tensor.
-    void SetPointAttr(const std::string &key, const core::Tensor &value) {
+    void SetPointAttr(const std::string& key, const core::Tensor& value) {
         if (value.GetDevice() != device_) {
             utility::LogError("Attribute device {} != Pointcloud's device {}.",
                               value.GetDevice().ToString(), device_.ToString());
@@ -164,19 +164,19 @@ class PointCloud : public Geometry, public DrawableGeometry {
     }
 
     /// Set the value of the "positions" attribute. Convenience function.
-    void SetPointPositions(const core::Tensor &value) {
+    void SetPointPositions(const core::Tensor& value) {
         core::AssertTensorShape(value, {std::nullopt, 3});
         SetPointAttr("positions", value);
     }
 
     /// Set the value of the "colors" attribute. Convenience function.
-    void SetPointColors(const core::Tensor &value) {
+    void SetPointColors(const core::Tensor& value) {
         core::AssertTensorShape(value, {std::nullopt, 3});
         SetPointAttr("colors", value);
     }
 
     /// Set the value of the "normals" attribute. Convenience function.
-    void SetPointNormals(const core::Tensor &value) {
+    void SetPointNormals(const core::Tensor& value) {
         core::AssertTensorShape(value, {std::nullopt, 3});
         SetPointAttr("normals", value);
     }
@@ -185,7 +185,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// 1) attribute key exist
     /// 2) attribute's length as points' length
     /// 3) attribute's length > 0
-    bool HasPointAttr(const std::string &key) const {
+    bool HasPointAttr(const std::string& key) const {
         return point_attr_.Contains(key) && GetPointAttr(key).GetLength() > 0 &&
                GetPointAttr(key).GetLength() == GetPointPositions().GetLength();
     }
@@ -194,7 +194,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// cannot be removed. Throws warning if attribute key does not exists.
     ///
     /// \param key Attribute name.
-    void RemovePointAttr(const std::string &key) { point_attr_.Erase(key); }
+    void RemovePointAttr(const std::string& key) { point_attr_.Erase(key); }
 
     /// Check if the "positions" attribute's value has length > 0.
     /// This is a convenience function.
@@ -220,13 +220,13 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param copy If true, a new point cloud is always created; if false, the
     /// copy is avoided when the original point cloud is already on the targeted
     /// device.
-    PointCloud To(const core::Device &device, bool copy = false) const;
+    PointCloud To(const core::Device& device, bool copy = false) const;
 
     /// Returns copy of the point cloud on the same device.
     PointCloud Clone() const;
 
     /// Clear all data in the point cloud.
-    PointCloud &Clear() override {
+    PointCloud& Clear() override {
         point_attr_.clear();
         return *this;
     }
@@ -248,11 +248,11 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// The point cloud being appended, must have all the attributes
     /// present in the point cloud it is being appended to, with same
     /// dtype, device and same shape other than the first dimension / length.
-    PointCloud Append(const PointCloud &other) const;
+    PointCloud Append(const PointCloud& other) const;
 
     /// operator+ for t::PointCloud appends the compatible attributes to the
     /// point cloud.
-    PointCloud operator+(const PointCloud &other) const {
+    PointCloud operator+(const PointCloud& other) const {
         return Append(other);
     }
 
@@ -273,38 +273,61 @@ class PointCloud : public Geometry, public DrawableGeometry {
     ///
     ///   [x, y, z] = [x', y', z'] / w'
     ///
+    /// \note For Gaussian splat point clouds (IsGaussianSplat()), the
+    ///   Gaussian-specific attributes (rot, scale, f_dc, f_rest) are
+    ///   **not** updated because the linear part of a general 4x4 matrix
+    ///   may be non-orthogonal. A warning is logged. Use Rotate(), Scale(),
+    ///   and Translate() to transform splat clouds consistently.
+    ///
     /// \param transformation Transformation [Tensor of dim {4,4}].
     /// \return Transformed point cloud
-    PointCloud &Transform(const core::Tensor &transformation);
+    PointCloud& Transform(const core::Tensor& transformation);
 
     /// \brief Translates the PointPositions of the PointCloud.
     /// \param translation translation tensor of dimension {3}
     /// Should be on the same device as the PointCloud
     /// \param relative if true (default): translates relative to Center
     /// \return Translated point cloud
-    PointCloud &Translate(const core::Tensor &translation,
+    PointCloud& Translate(const core::Tensor& translation,
                           bool relative = true);
 
     /// \brief Scales the PointPositions of the PointCloud.
+    ///
+    /// \note For Gaussian splat point clouds (IsGaussianSplat()), the linear
+    ///   scale attributes are multiplied by |scale|. Negative scale means
+    ///   point inversion + uniform scaling: positions are mirrored, axis
+    ///   lengths scale by |scale|, and odd-degree SH bands in f_rest are
+    ///   negated. Quaternions, f_dc, and opacity are unchanged.
+    ///
     /// \param scale Scale [double] of dimension
     /// \param center Center [Tensor of dim {3}] about which the PointCloud is
     /// to be scaled. Should be on the same device as the PointCloud
     /// \return Scaled point cloud
-    PointCloud &Scale(double scale, const core::Tensor &center);
+    PointCloud& Scale(double scale, const core::Tensor& center);
 
     /// \brief Rotates the PointPositions and PointNormals (if exists).
+    ///
+    /// \note For Gaussian splat point clouds (IsGaussianSplat()), the
+    ///   per-splat quaternion orientations (rot) are composed with
+    ///   Quaternion(R) on CPU, and the SH rest coefficients (f_rest) are
+    ///   rotated via the Ivanic–Ruedenberg recursion on all devices. A proper
+    ///   rotation matrix is assumed, consistent with how normals are rotated
+    ///   (n' = R n, no orthogonality check). The linear scale attributes and
+    ///   f_dc are unchanged. A warning is logged if rot cannot be updated
+    ///   (non-CPU).
+    ///
     /// \param R Rotation [Tensor of dim {3,3}].
     /// Should be on the same device as the PointCloud
     /// \param center Center [Tensor of dim {3}] about which the PointCloud is
-    /// to be scaled. Should be on the same device as the PointCloud
+    /// to be rotated. Should be on the same device as the PointCloud
     /// \return Rotated point cloud
-    PointCloud &Rotate(const core::Tensor &R, const core::Tensor &center);
+    PointCloud& Rotate(const core::Tensor& R, const core::Tensor& center);
 
     /// \brief Assigns uniform color to the point cloud.
     ///
     /// \param color  RGB color for the point cloud. {3,} shaped Tensor.
     /// Floating color values are clipped between 0.0 and 1.0.
-    PointCloud &PaintUniformColor(const core::Tensor &color);
+    PointCloud& PaintUniformColor(const core::Tensor& color);
 
     /// \brief Select points from input pointcloud, based on boolean mask
     /// indices into output point cloud.
@@ -312,7 +335,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param boolean_mask Boolean indexing tensor of shape {n,} containing
     /// true value for the indices that is to be selected.
     /// \param invert Set to `True` to invert the selection of indices.
-    PointCloud SelectByMask(const core::Tensor &boolean_mask,
+    PointCloud SelectByMask(const core::Tensor& boolean_mask,
                             bool invert = false) const;
 
     /// \brief Select points from input pointcloud, based on indices list into
@@ -323,7 +346,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param invert Set to `True` to invert the selection of indices, and also
     /// ignore the duplicated indices.
     /// \param remove_duplicates Set to `True` to remove the duplicated indices.
-    PointCloud SelectByIndex(const core::Tensor &indices,
+    PointCloud SelectByIndex(const core::Tensor& indices,
                              bool invert = false,
                              bool remove_duplicates = false) const;
 
@@ -332,7 +355,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param voxel_size Voxel size. A positive number.
     /// \param reduction Reduction type. Currently only support "mean".
     PointCloud VoxelDownSample(double voxel_size,
-                               const std::string &reduction = "mean") const;
+                               const std::string& reduction = "mean") const;
 
     /// \brief Downsamples a point cloud by selecting every kth index point and
     /// its attributes.
@@ -414,7 +437,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \return Tuple of visible triangle mesh and indices of visible points on
     /// the same device as the point cloud.
     std::tuple<TriangleMesh, core::Tensor> HiddenPointRemoval(
-            const core::Tensor &camera_location, double radius) const;
+            const core::Tensor& camera_location, double radius) const;
 
     /// \brief Cluster PointCloud using the DBSCAN algorithm
     /// Ester et al., "A Density-Based Algorithm for Discovering Clusters
@@ -483,7 +506,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
 
 public:
     /// Normalize point normals to length 1.
-    PointCloud &NormalizeNormals();
+    PointCloud& NormalizeNormals();
 
     /// \brief Function to estimate point normals. If the point cloud normals
     /// exist, the estimated normals are oriented with respect to the same.
@@ -504,7 +527,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param orientation_reference Normals are oriented with respect to
     /// orientation_reference.
     void OrientNormalsToAlignWithDirection(
-            const core::Tensor &orientation_reference =
+            const core::Tensor& orientation_reference =
                     core::Tensor::Init<float>({0, 0, 1},
                                               core::Device("CPU:0")));
 
@@ -513,7 +536,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param camera_location Normals are oriented with towards the
     /// camera_location.
     void OrientNormalsTowardsCameraLocation(
-            const core::Tensor &camera_location = core::Tensor::Zeros(
+            const core::Tensor& camera_location = core::Tensor::Zeros(
                     {3}, core::Float32, core::Device("CPU:0")));
 
     /// \brief Function to consistently orient estimated normals based on
@@ -575,9 +598,9 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \return Created point cloud with the 'points' property set. Thus is
     /// empty if the conversion fails.
     static PointCloud CreateFromDepthImage(
-            const Image &depth,
-            const core::Tensor &intrinsics,
-            const core::Tensor &extrinsics =
+            const Image& depth,
+            const core::Tensor& intrinsics,
+            const core::Tensor& extrinsics =
                     core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
             float depth_scale = 1000.0f,
             float depth_max = 3.0f,
@@ -610,9 +633,9 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \return Created point cloud with the 'points' and 'colors' properties
     /// set. This is empty if the conversion fails.
     static PointCloud CreateFromRGBDImage(
-            const RGBDImage &rgbd_image,
-            const core::Tensor &intrinsics,
-            const core::Tensor &extrinsics =
+            const RGBDImage& rgbd_image,
+            const core::Tensor& intrinsics,
+            const core::Tensor& extrinsics =
                     core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
             float depth_scale = 1000.0f,
             float depth_max = 3.0f,
@@ -621,9 +644,9 @@ class PointCloud : public Geometry, public DrawableGeometry {
 
     /// Create a PointCloud from a legacy Open3D PointCloud.
     static PointCloud FromLegacy(
-            const open3d::geometry::PointCloud &pcd_legacy,
+            const open3d::geometry::PointCloud& pcd_legacy,
             core::Dtype dtype = core::Float32,
-            const core::Device &device = core::Device("CPU:0"));
+            const core::Device& device = core::Device("CPU:0"));
 
     /// Convert to a legacy Open3D PointCloud.
     open3d::geometry::PointCloud ToLegacy() const;
@@ -632,8 +655,8 @@ class PointCloud : public Geometry, public DrawableGeometry {
     geometry::Image ProjectToDepthImage(
             int width,
             int height,
-            const core::Tensor &intrinsics,
-            const core::Tensor &extrinsics =
+            const core::Tensor& intrinsics,
+            const core::Tensor& extrinsics =
                     core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
             float depth_scale = 1000.0f,
             float depth_max = 3.0f);
@@ -642,8 +665,8 @@ class PointCloud : public Geometry, public DrawableGeometry {
     geometry::RGBDImage ProjectToRGBDImage(
             int width,
             int height,
-            const core::Tensor &intrinsics,
-            const core::Tensor &extrinsics =
+            const core::Tensor& intrinsics,
+            const core::Tensor& extrinsics =
                     core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
             float depth_scale = 1000.0f,
             float depth_max = 3.0f);
@@ -659,7 +682,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param aabb AxisAlignedBoundingBox to crop points.
     /// \param invert Crop the points outside of the bounding box or inside of
     /// the bounding box.
-    PointCloud Crop(const AxisAlignedBoundingBox &aabb,
+    PointCloud Crop(const AxisAlignedBoundingBox& aabb,
                     bool invert = false) const;
 
     /// \brief Function to crop pointcloud into output pointcloud.
@@ -667,7 +690,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param obb OrientedBoundingBox to crop points.
     /// \param invert Crop the points outside of the bounding box or inside of
     /// the bounding box.
-    PointCloud Crop(const OrientedBoundingBox &obb, bool invert = false) const;
+    PointCloud Crop(const OrientedBoundingBox& obb, bool invert = false) const;
 
     /// Sweeps the point cloud rotationally about an axis.
     /// \param angle The rotation angle in degree.
@@ -678,7 +701,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// \param capping If true adds caps to the mesh.
     /// \return A line set with the result of the sweep operation.
     LineSet ExtrudeRotation(double angle,
-                            const core::Tensor &axis,
+                            const core::Tensor& axis,
                             int resolution = 16,
                             double translation = 0.0,
                             bool capping = true) const;
@@ -689,7 +712,7 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// vector.
     /// \param capping If true adds caps to the mesh.
     /// \return A line set with the result of the sweep operation.
-    LineSet ExtrudeLinear(const core::Tensor &vector,
+    LineSet ExtrudeLinear(const core::Tensor& vector,
                           double scale = 1.0,
                           bool capping = true) const;
 
@@ -734,13 +757,22 @@ class PointCloud : public Geometry, public DrawableGeometry {
     /// different metrics.
     /// \returns Tensor containing the requested metrics.
     core::Tensor ComputeMetrics(
-            const PointCloud &pcd2,
+            const PointCloud& pcd2,
             std::vector<Metric> metrics = {Metric::ChamferDistance},
             MetricParameters params = MetricParameters()) const;
 
     /// Check if this point cloud has all the attributes required for a Gaussian
     /// Splat. This checks for the presence of scale, rot, opacity and f_dc
     /// attributes.
+    ///
+    /// \note For 3D Gaussian splats, the \c "scale" point attribute is stored
+    /// in
+    /// \b linear space (axis lengths), consistent with rendering. PLY files
+    /// from typical 3DGS tools store scales in log-space; \c
+    /// t::io::ReadPointCloudFromPLY converts them to linear on load. SPLAT
+    /// files store linear scales and are copied as-is. When writing PLY, scales
+    /// are converted back to log-space for compatibility with common PLY
+    /// conventions.
     /// \returns True if a valid 3DGS point cloud, else False.
     /// \throws If point cloud has 3DGS attributes, but they are invalid (wrong
     /// shape).
diff --git a/cpp/open3d/t/io/PointCloudIO.h b/cpp/open3d/t/io/PointCloudIO.h
index 51d9d8a3f15..4499ba4fd96 100644
--- a/cpp/open3d/t/io/PointCloudIO.h
+++ b/cpp/open3d/t/io/PointCloudIO.h
@@ -66,6 +66,9 @@ bool WritePointCloudToPCD(const std::string &filename,
                           const geometry::PointCloud &pointcloud,
                           const WritePointCloudOption &params);
 
+/// Reads PLY; for Gaussian-splat point clouds, per-point \c "scale" in the file
+/// is interpreted as log-scale and converted to linear in the returned
+/// \c PointCloud (see \c t::geometry::PointCloud::IsGaussianSplat()).
 bool ReadPointCloudFromPLY(const std::string &filename,
                            geometry::PointCloud &pointcloud,
                            const ReadPointCloudOption &params);
@@ -74,6 +77,8 @@ bool WritePointCloudToPLY(const std::string &filename,
                           const geometry::PointCloud &pointcloud,
                           const WritePointCloudOption &params);
 
+/// Reads the binary SPLAT format; per-point \c "scale" matches the in-memory
+/// representation (linear axis lengths).
 bool ReadPointCloudFromSPLAT(const std::string &filename,
                              geometry::PointCloud &pointcloud,
                              const ReadPointCloudOption &params);
diff --git a/cpp/open3d/t/io/file_format/FilePLY.cpp b/cpp/open3d/t/io/file_format/FilePLY.cpp
index 1d81a9f268d..45826ee23d3 100644
--- a/cpp/open3d/t/io/file_format/FilePLY.cpp
+++ b/cpp/open3d/t/io/file_format/FilePLY.cpp
@@ -7,6 +7,7 @@
 
 #include <rply.h>
 
+#include <cmath>
 #include <vector>
 
 #include "open3d/core/Dtype.h"
@@ -31,7 +32,7 @@ constexpr auto F_REST_SUFFIX_INDEX = std::char_traits<char>::length("f_rest_");
 struct PLYReaderState {
     struct AttrState {
         std::string name_;
-        void *data_ptr_;
+        void* data_ptr_;
         int stride_;
         int offset_;
         int64_t size_;
@@ -39,22 +40,22 @@ struct PLYReaderState {
     };
     // Allow fast access of attr_state by index.
     std::vector<std::shared_ptr<AttrState>> id_to_attr_state_;
-    utility::CountingProgressReporter *progress_bar_;
+    utility::CountingProgressReporter* progress_bar_;
 };
 
 template <typename T>
 int ReadAttributeCallback(p_ply_argument argument) {
-    PLYReaderState *state_ptr;
+    PLYReaderState* state_ptr;
     long id;
-    ply_get_argument_user_data(argument, reinterpret_cast<void **>(&state_ptr),
+    ply_get_argument_user_data(argument, reinterpret_cast<void**>(&state_ptr),
                                &id);
-    std::shared_ptr<PLYReaderState::AttrState> &attr_state =
+    std::shared_ptr<PLYReaderState::AttrState>& attr_state =
             state_ptr->id_to_attr_state_[id];
     if (attr_state->current_size_ >= attr_state->size_) {
         return 0;
     }
 
-    T *data_ptr = static_cast<T *>(attr_state->data_ptr_);
+    T* data_ptr = static_cast<T*>(attr_state->data_ptr_);
     const int64_t index = attr_state->stride_ * attr_state->current_size_ +
                           attr_state->offset_;
     data_ptr[index] = static_cast<T>(ply_get_argument_value(argument));
@@ -131,7 +132,7 @@ core::Dtype GetDtype(e_ply_type type) {
 
 // Map ply attributes to Open3D point cloud attributes
 std::tuple<std::string, int, int> GetNameStrideOffsetForAttribute(
-        const std::string &name) {
+        const std::string& name) {
     // Positions attribute.
     if (name == "x") return std::make_tuple("positions", 3, 0);
     if (name == "y") return std::make_tuple("positions", 3, 1);
@@ -173,9 +174,9 @@ std::tuple<std::string, int, int> GetNameStrideOffsetForAttribute(
 
 }  // namespace
 
-bool ReadPointCloudFromPLY(const std::string &filename,
-                           geometry::PointCloud &pointcloud,
-                           const open3d::io::ReadPointCloudOption &params) {
+bool ReadPointCloudFromPLY(const std::string& filename,
+                           geometry::PointCloud& pointcloud,
+                           const open3d::io::ReadPointCloudOption& params) {
     p_ply ply_file = ply_open(filename.c_str(), nullptr, 0, nullptr);
     if (!ply_file) {
         utility::LogWarning("Read PLY failed: unable to open file: {}.",
@@ -190,7 +191,7 @@ bool ReadPointCloudFromPLY(const std::string &filename,
 
     PLYReaderState state;
 
-    const char *element_name;
+    const char* element_name;
     long element_size = 0;
     // Loop through ply elements and find "vertex".
     p_ply_element element = ply_get_next_element(ply_file, nullptr);
@@ -221,7 +222,7 @@ bool ReadPointCloudFromPLY(const std::string &filename,
 
     while (attribute) {
         e_ply_type type;
-        const char *name;
+        const char* name;
         ply_get_property_info(attribute, &name, &type, nullptr, nullptr);
 
         if (GetDtype(type) == core::Undefined) {
@@ -288,11 +289,19 @@ bool ReadPointCloudFromPLY(const std::string &filename,
                 core::Tensor::Empty({element_size, f_rest_count / 3, 3},
                                     core::Float32, pointcloud.GetDevice());
         pointcloud.SetPointAttr("f_rest", new_f_rest);
-        for (auto &attr_state : state.id_to_attr_state_) {
+        for (auto& attr_state : state.id_to_attr_state_) {
             if (attr_state->name_ == "f_rest") {
                 attr_state->data_ptr_ =
                         pointcloud.GetPointAttr("f_rest").GetDataPtr();
+                // GraphDECO / 3DGS PLY stores f_rest properties channel-major:
+                //   R[0..Nc), G[0..Nc), B[0..Nc).
+                // Open3D stores f_rest as {N, Nc, 3}, i.e. basis-major RGB
+                // triples. Remap each property offset into the tensor layout.
+                const int basis_count = f_rest_count / 3;
+                const int channel = attr_state->offset_ / basis_count;
+                const int basis = attr_state->offset_ % basis_count;
                 attr_state->stride_ = f_rest_count;
+                attr_state->offset_ = basis * 3 + channel;
             }
         }
     }
@@ -313,13 +322,25 @@ bool ReadPointCloudFromPLY(const std::string &filename,
 
     if (pointcloud.IsGaussianSplat()) {  // validates 3DGS, if present.
         utility::LogDebug("PLY file contains a Gaussian Splat.");
+        // PLY files store scales in log-space; convert to linear so the
+        // canonical representation in PointCloud is always linear.
+        if (pointcloud.HasPointAttr("scale")) {
+            auto& scale_t = pointcloud.GetPointAttr("scale");
+            auto scale_f32 = scale_t.To(core::Float32).Contiguous();
+            float* ptr = scale_f32.GetDataPtr<float>();
+            const int64_t n = scale_f32.NumElements();
+            for (int64_t k = 0; k < n; ++k) {
+                ptr[k] = std::exp(ptr[k]);
+            }
+            pointcloud.SetPointAttr("scale", scale_f32);
+        }
     }
 
     return true;
 }
 
 namespace {
-e_ply_type GetPlyType(const core::Dtype &dtype) {
+e_ply_type GetPlyType(const core::Dtype& dtype) {
     if (dtype == core::UInt8) {
         return PLY_UCHAR;
     } else if (dtype == core::UInt16) {
@@ -340,20 +361,20 @@ e_ply_type GetPlyType(const core::Dtype &dtype) {
 }
 
 struct AttributePtr {
-    AttributePtr(const core::Dtype &dtype,
-                 const void *data_ptr,
-                 const int &group_size)
+    AttributePtr(const core::Dtype& dtype,
+                 const void* data_ptr,
+                 const int& group_size)
         : dtype_(dtype), data_ptr_(data_ptr), group_size_(group_size) {}
 
     const core::Dtype dtype_;
-    const void *data_ptr_;
+    const void* data_ptr_;
     const int group_size_;
 };
 }  // namespace
 
-bool WritePointCloudToPLY(const std::string &filename,
-                          const geometry::PointCloud &pointcloud,
-                          const open3d::io::WritePointCloudOption &params) {
+bool WritePointCloudToPLY(const std::string& filename,
+                          const geometry::PointCloud& pointcloud,
+                          const open3d::io::WritePointCloudOption& params) {
     if (pointcloud.IsEmpty()) {
         utility::LogWarning("Write PLY failed: point cloud has 0 points.");
         return false;
@@ -366,13 +387,28 @@ bool WritePointCloudToPLY(const std::string &filename,
     geometry::TensorMap t_map =
             pointcloud.To(core::Device("CPU:0")).GetPointAttr().Contiguous();
 
+    // PLY files store 3DGS scales in log-space. Convert the canonical linear
+    // "scale" attribute to log before writing, then restore after.
+    core::Tensor scale_log_copy;
+    if (pointcloud.IsGaussianSplat() && t_map.Contains("scale")) {
+        auto scale_f32 = t_map["scale"].To(core::Float32).Contiguous();
+        const int64_t n = scale_f32.NumElements();
+        scale_log_copy = scale_f32.Clone();
+        float* ptr = scale_log_copy.GetDataPtr<float>();
+        for (int64_t k = 0; k < n; ++k) {
+            // Guard against zero/negative linear scales before log.
+            ptr[k] = std::log(std::max(ptr[k], 1e-20f));
+        }
+        t_map["scale"] = scale_log_copy;
+    }
+
     long num_points =
             static_cast<long>(pointcloud.GetPointPositions().GetLength());
 
     // Verify that standard attributes have length equal to num_points.
     // Extra attributes must have at least 2 dimensions: (num_points, channels,
     // ...).
-    for (auto const &it : t_map) {
+    for (auto const& it : t_map) {
         if (it.first == "positions" || it.first == "normals" ||
             it.first == "colors") {
             if (it.second.GetLength() != num_points) {
@@ -453,7 +489,7 @@ bool WritePointCloudToPLY(const std::string &filename,
     // channels are flattened, and each channel is written as a separate
     // property (e.g., "f_rest_0", "f_rest_1", ...).
     e_ply_type attributeType;
-    for (auto const &it : t_map) {
+    for (auto const& it : t_map) {
         if (it.first == "positions" || it.first == "colors" ||
             it.first == "normals")
             continue;
@@ -494,8 +530,8 @@ bool WritePointCloudToPLY(const std::string &filename,
     for (int64_t i = 0; i < num_points; i++) {
         for (auto it : attribute_ptrs) {
             DISPATCH_DTYPE_TO_TEMPLATE(it.dtype_, [&]() {
-                const scalar_t *data_ptr =
-                        static_cast<const scalar_t *>(it.data_ptr_);
+                const scalar_t* data_ptr =
+                        static_cast<const scalar_t*>(it.data_ptr_);
                 for (int idx_offset = it.group_size_ * i;
                      idx_offset < it.group_size_ * (i + 1); ++idx_offset) {
                     ply_write(ply_file, data_ptr[idx_offset]);
diff --git a/cpp/open3d/t/io/file_format/FileSPLAT.cpp b/cpp/open3d/t/io/file_format/FileSPLAT.cpp
index 8f58111bf4f..4e1ab1a6c46 100644
--- a/cpp/open3d/t/io/file_format/FileSPLAT.cpp
+++ b/cpp/open3d/t/io/file_format/FileSPLAT.cpp
@@ -34,8 +34,8 @@ constexpr int SPLAT_GAUSSIAN_BYTE_SIZE = 32;
 inline double sigmoid(double x) { return 1.0 / (1.0 + std::exp(-x)); }
 
 template <typename scalar_t>
-Eigen::Array<uint8_t, 4, 1> ComputeColor(const scalar_t *f_dc_ptr,
-                                         const scalar_t *opacity_ptr) {
+Eigen::Array<uint8_t, 4, 1> ComputeColor(const scalar_t* f_dc_ptr,
+                                         const scalar_t* opacity_ptr) {
     Eigen::Array<float, 4, 1> color;
     color[0] = 0.5 + SH_C0 * f_dc_ptr[0];
     color[1] = 0.5 + SH_C0 * f_dc_ptr[1];
@@ -47,33 +47,32 @@ Eigen::Array<uint8_t, 4, 1> ComputeColor(const scalar_t *f_dc_ptr,
 
 /// Sort Gaussians in descending order according to -exp(\sum scales) / (1 +
 /// exp(-opacity)) and return the sorted order.
-std::vector<int64_t> SortedSplatIndices(geometry::TensorMap &t_map) {
+std::vector<int64_t> SortedSplatIndices(geometry::TensorMap& t_map) {
     auto num_gaussians = t_map["opacity"].GetShape(0);
     std::vector<int64_t> indices(num_gaussians);
     std::iota(indices.begin(), indices.end(), 0);
 
     // Get pointers to data
-    const float *scale_data = t_map["scale"].GetDataPtr<float>();
-    const float *opacity_data = t_map["opacity"].GetDataPtr<float>();
+    const float* scale_data = t_map["scale"].GetDataPtr<float>();
+    const float* opacity_data = t_map["opacity"].GetDataPtr<float>();
     const auto scle_grp_size = t_map["scale"].GetShape(1);
 
-    // Custom sorting function using the given formula
+    // Sort by descending volume × opacity — larger, more opaque splats first.
+    // Scales are now linear (volume proxy = s0*s1*s2), opacity is in logit
+    // space.
     tbb::parallel_sort(
             indices.begin(), indices.end(),
             [&](size_t left, size_t right) -> bool {
-                // Compute scores for left and right elements
-                float scale_left = scale_data[left * scle_grp_size] +
-                                   scale_data[left * scle_grp_size + 1] +
-                                   scale_data[left * scle_grp_size + 2];
-                float scale_right = scale_data[right * scle_grp_size] +
-                                    scale_data[right * scle_grp_size + 1] +
-                                    scale_data[right * scle_grp_size + 2];
-
-                float score_left = -std::exp(scale_left) /
-                                   (1 + std::exp(-opacity_data[left]));
-                float score_right = -std::exp(scale_right) /
-                                    (1 + std::exp(-opacity_data[right]));
-
+                float vol_left = scale_data[left * scle_grp_size] *
+                                 scale_data[left * scle_grp_size + 1] *
+                                 scale_data[left * scle_grp_size + 2];
+                float vol_right = scale_data[right * scle_grp_size] *
+                                  scale_data[right * scle_grp_size + 1] *
+                                  scale_data[right * scle_grp_size + 2];
+                float score_left =
+                        -vol_left / (1.0f + std::exp(-opacity_data[left]));
+                float score_right =
+                        -vol_right / (1.0f + std::exp(-opacity_data[right]));
                 return score_left < score_right;  // Sort in descending order
             });
     return indices;
@@ -81,9 +80,9 @@ std::vector<int64_t> SortedSplatIndices(geometry::TensorMap &t_map) {
 
 }  // End of anonymous namespace
 
-bool ReadPointCloudFromSPLAT(const std::string &filename,
-                             geometry::PointCloud &pointcloud,
-                             const open3d::io::ReadPointCloudOption &params) {
+bool ReadPointCloudFromSPLAT(const std::string& filename,
+                             geometry::PointCloud& pointcloud,
+                             const open3d::io::ReadPointCloudOption& params) {
     try {
         // Open the file
         utility::filesystem::CFile file;
@@ -110,12 +109,12 @@ bool ReadPointCloudFromSPLAT(const std::string &filename,
 
         // Constants
         char buffer[SPLAT_GAUSSIAN_BYTE_SIZE];
-        const char *buffer_position = buffer;
-        const char *buffer_scale = buffer_position + 3 * sizeof(float);
-        const uint8_t *buffer_color =
-                reinterpret_cast<const uint8_t *>(buffer_scale) +
+        const char* buffer_position = buffer;
+        const char* buffer_scale = buffer_position + 3 * sizeof(float);
+        const uint8_t* buffer_color =
+                reinterpret_cast<const uint8_t*>(buffer_scale) +
                 3 * sizeof(float);
-        const uint8_t *buffer_rotation = buffer_color + 4 * sizeof(uint8_t);
+        const uint8_t* buffer_rotation = buffer_color + 4 * sizeof(uint8_t);
         int number_of_points =
                 static_cast<int>(file_size / SPLAT_GAUSSIAN_BYTE_SIZE);
 
@@ -139,13 +138,13 @@ bool ReadPointCloudFromSPLAT(const std::string &filename,
                 "opacity",
                 core::Tensor::Empty({number_of_points, 1}, core::Float32));
 
-        float *position_ptr =
+        float* position_ptr =
                 pointcloud.GetPointPositions().GetDataPtr<float>();
-        float *scale_ptr = pointcloud.GetPointAttr("scale").GetDataPtr<float>();
-        float *f_dc_ptr = pointcloud.GetPointAttr("f_dc").GetDataPtr<float>();
-        float *opacity_ptr =
+        float* scale_ptr = pointcloud.GetPointAttr("scale").GetDataPtr<float>();
+        float* f_dc_ptr = pointcloud.GetPointAttr("f_dc").GetDataPtr<float>();
+        float* opacity_ptr =
                 pointcloud.GetPointAttr("opacity").GetDataPtr<float>();
-        float *rot_ptr = pointcloud.GetPointAttr("rot").GetDataPtr<float>();
+        float* rot_ptr = pointcloud.GetPointAttr("rot").GetDataPtr<float>();
 
         // Read the data
         for (size_t index = 0; file.ReadData(buffer, SPLAT_GAUSSIAN_BYTE_SIZE);
@@ -153,25 +152,29 @@ bool ReadPointCloudFromSPLAT(const std::string &filename,
             // Copy the data into the vectors
             std::memcpy(position_ptr + index * 3, buffer_position,
                         3 * sizeof(float));
+            // SPLAT format stores linear scales; canonical PointCloud
+            // representation is also linear, so no conversion needed.
             std::memcpy(scale_ptr + index * 3, buffer_scale, 3 * sizeof(float));
 
             // Calculate the f_dc
-            float *f_dc = f_dc_ptr + index * 3;
+            float* f_dc = f_dc_ptr + index * 3;
             for (int i = 0; i < 3; i++) {
                 f_dc[i] = ((buffer_color[i] / 255.0) - 0.5) / SH_C0;
             }
             // Calculate the opacity
-            float *opacity = opacity_ptr + index;
+            float* opacity = opacity_ptr + index;
             if (buffer_color[3] == 0) {
-                opacity[0] = 0.0f;  // Handle division by zero
+                opacity[0] =
+                        std::numeric_limits<float>::lowest();  // logit(0) ≈ -∞
             } else if (buffer_color[3] == 255) {
-                opacity[0] = -std::numeric_limits<float>::lowest();  // -log(0)
+                opacity[0] =
+                        std::numeric_limits<float>::max();  // logit(1) ≈ +∞
             } else {
-                opacity[0] = -log(1 / (buffer_color[3] / 255.0) - 1);
+                opacity[0] = -std::log(255.f / buffer_color[3] - 1.0f);
             }
             // Calculate the rotation quaternion.
             // Normalize to reduce quantization error
-            float *rot_float = rot_ptr + index * 4;
+            float* rot_float = rot_ptr + index * 4;
             float quat_norm = 0;
             for (int i = 0; i < 4; i++) {
                 rot_float[i] = (buffer_rotation[i] / 128.0) - 1.0;
@@ -197,15 +200,15 @@ bool ReadPointCloudFromSPLAT(const std::string &filename,
         // Report progress
         reporter.Finish();
         return true;
-    } catch (const std::exception &e) {
+    } catch (const std::exception& e) {
         utility::LogError("Read SPLAT file {} failed: {}", filename, e.what());
     }
     return false;
 }
 
-bool WritePointCloudToSPLAT(const std::string &filename,
-                            const geometry::PointCloud &pointcloud,
-                            const open3d::io::WritePointCloudOption &params) {
+bool WritePointCloudToSPLAT(const std::string& filename,
+                            const geometry::PointCloud& pointcloud,
+                            const open3d::io::WritePointCloudOption& params) {
     // Validate Point Cloud
     if (pointcloud.IsEmpty()) {
         utility::LogWarning("Write SPLAT failed: point cloud has 0 points.");
@@ -229,11 +232,11 @@ bool WritePointCloudToSPLAT(const std::string &filename,
                               .Contiguous()
                               .To(core::Device("CPU:0"));
     }
-    float *positions_ptr = t_map["positions"].GetDataPtr<float>();
-    float *scale_ptr = t_map["scale"].GetDataPtr<float>();
-    float *f_dc_ptr = t_map["f_dc"].GetDataPtr<float>();
-    float *opacity_ptr = t_map["opacity"].GetDataPtr<float>();
-    float *rot_ptr = t_map["rot"].GetDataPtr<float>();
+    float* positions_ptr = t_map["positions"].GetDataPtr<float>();
+    float* scale_ptr = t_map["scale"].GetDataPtr<float>();
+    float* f_dc_ptr = t_map["f_dc"].GetDataPtr<float>();
+    float* opacity_ptr = t_map["opacity"].GetDataPtr<float>();
+    float* rot_ptr = t_map["rot"].GetDataPtr<float>();
     constexpr int N_POSITIONS = 3;
     constexpr int N_SCALE = 3;
     constexpr int N_F_DC = 3;
@@ -249,7 +252,7 @@ bool WritePointCloudToSPLAT(const std::string &filename,
     try {
         splat_file.exceptions(std::ofstream::badbit);  // failbit not set for
                                                        // binary IO errors
-    } catch (const std::ios_base::failure &) {
+    } catch (const std::ios_base::failure&) {
         utility::LogWarning("Write SPLAT failed: unable to open file: {}.",
                             filename);
         return false;
@@ -266,19 +269,20 @@ bool WritePointCloudToSPLAT(const std::string &filename,
             int64_t g_idx = sorted_indices[i];
 
             // Positions
-            splat_file.write(reinterpret_cast<const char *>(
-                                     positions_ptr + N_POSITIONS * g_idx),
+            splat_file.write(reinterpret_cast<const char*>(positions_ptr +
+                                                           N_POSITIONS * g_idx),
                              N_POSITIONS * sizeof(float));
 
-            // Scale
+            // Scale: canonical representation is linear; SPLAT format is also
+            // linear, so write directly.
             splat_file.write(
-                    reinterpret_cast<const char *>(scale_ptr + N_SCALE * g_idx),
+                    reinterpret_cast<const char*>(scale_ptr + N_SCALE * g_idx),
                     N_SCALE * sizeof(float));
 
             // Color
             auto color = ComputeColor(f_dc_ptr + N_F_DC * g_idx,
                                       opacity_ptr + N_OPACITY * g_idx);
-            splat_file.write(reinterpret_cast<const char *>(color.data()),
+            splat_file.write(reinterpret_cast<const char*>(color.data()),
                              4 * sizeof(uint8_t));
 
             // Rot
@@ -297,7 +301,7 @@ bool WritePointCloudToSPLAT(const std::string &filename,
             rot = (rot * 128.0).array().round() + 128.0;
             auto uint8_rot =
                     rot.cwiseMin(255.0).cwiseMax(0.0).cast<uint8_t>().eval();
-            splat_file.write(reinterpret_cast<const char *>(uint8_rot.data()),
+            splat_file.write(reinterpret_cast<const char*>(uint8_rot.data()),
                              4 * sizeof(uint8_t));
 
             if (i % 1000 == 0) {
@@ -307,7 +311,7 @@ bool WritePointCloudToSPLAT(const std::string &filename,
         splat_file.close();  // Close file, flushes to disk.
         reporter.Finish();
         return true;
-    } catch (const std::ios_base::failure &e) {
+    } catch (const std::ios_base::failure& e) {
         utility::LogWarning("Write SPLAT to file {} failed: {}", filename,
                             e.what());
         return false;
diff --git a/cpp/open3d/visualization/gui/MenuMacOS.mm b/cpp/open3d/visualization/gui/MenuMacOS.mm
index 3e0a553584b..f396c01bae9 100644
--- a/cpp/open3d/visualization/gui/MenuMacOS.mm
+++ b/cpp/open3d/visualization/gui/MenuMacOS.mm
@@ -17,14 +17,13 @@
 
 #include "open3d/visualization/gui/Application.h"
 
-@interface Open3DRunnable : NSObject
-{
+@interface Open3DRunnable : NSObject {
     std::function<void()> action_;
 }
 @end
 
 @implementation Open3DRunnable
-- (id)initWithFunction: (std::function<void()>)f {
+- (id)initWithFunction:(std::function<void()>)f {
     self = [super init];
     if (self) {
         action_ = f;
@@ -45,8 +44,7 @@ - (void)run {
     NSMenu *menu_;
     std::vector<std::shared_ptr<MenuMacOS>> submenus_;
 
-    NSMenuItem* FindMenuItem(ItemId itemId) const {
-
+    NSMenuItem *FindMenuItem(ItemId itemId) const {
         auto item = [this->menu_ itemWithTag:itemId];
         if (item != nil) {
             return item;
@@ -61,18 +59,16 @@ - (void)run {
 
         return nil;
     }
-
 };
 
-MenuMacOS::MenuMacOS()
-: impl_(new MenuMacOS::Impl()) {
+MenuMacOS::MenuMacOS() : impl_(new MenuMacOS::Impl()) {
     impl_->menu_ = [[NSMenu alloc] initWithTitle:@""];
     impl_->menu_.autoenablesItems = NO;
 }
 
-MenuMacOS::~MenuMacOS() {} // ARC will automatically release impl_->menu
+MenuMacOS::~MenuMacOS() {}  // ARC will automatically release impl_->menu
 
-void* MenuMacOS::GetNativePointer() { return impl_->menu_; }
+void *MenuMacOS::GetNativePointer() { return impl_->menu_; }
 
 void MenuMacOS::AddItem(const char *name,
                         ItemId item_id /*= NO_ITEM*/,
@@ -85,41 +81,42 @@ - (void)run {
 }
 
 void MenuMacOS::AddSeparator() {
-    [impl_->menu_ addItem: [NSMenuItem separatorItem]];
+    [impl_->menu_ addItem:[NSMenuItem separatorItem]];
 }
 
 void MenuMacOS::InsertItem(int index,
-                           const char* name,
+                           const char *name,
                            ItemId item_id /*= NO_ITEM*/,
                            KeyName key /*= KEY_NONE*/) {
     std::string shortcut;
     shortcut += char(key);
     NSString *objc_shortcut = [NSString stringWithUTF8String:shortcut.c_str()];
     auto item = [[NSMenuItem alloc]
-                 initWithTitle:[NSString stringWithUTF8String:name]
-                        action:@selector(run)
-                 keyEquivalent:objc_shortcut];
+            initWithTitle:[NSString stringWithUTF8String:name]
+                   action:@selector(run)
+            keyEquivalent:objc_shortcut];
     item.target = [[Open3DRunnable alloc] initWithFunction:[item_id]() {
         Application::GetInstance().OnMenuItemSelected(item_id);
     }];
     item.tag = item_id;
     if (index < impl_->menu_.numberOfItems) {
-        [impl_->menu_ insertItem:item atIndex: index];
+        [impl_->menu_ insertItem:item atIndex:index];
     } else {
         [impl_->menu_ addItem:item];
     }
 }
 
-void MenuMacOS::InsertMenu(int index, const char* name,
+void MenuMacOS::InsertMenu(int index,
+                           const char *name,
                            std::shared_ptr<MenuBase> submenu) {
     auto macos_submenu = std::dynamic_pointer_cast<MenuMacOS>(submenu);
     macos_submenu->impl_->menu_.title = [NSString stringWithUTF8String:name];
     auto item = [[NSMenuItem alloc]
-                 initWithTitle:[NSString stringWithUTF8String:name]
-                        action:nil
-                 keyEquivalent:@""];
+            initWithTitle:[NSString stringWithUTF8String:name]
+                   action:nil
+            keyEquivalent:@""];
     if (index < impl_->menu_.numberOfItems) {
-        [impl_->menu_ insertItem:item atIndex: index];
+        [impl_->menu_ insertItem:item atIndex:index];
     } else {
         [impl_->menu_ addItem:item];
     }
@@ -128,12 +125,10 @@ - (void)run {
 }
 
 void MenuMacOS::InsertSeparator(int index) {
-    [impl_->menu_ insertItem: [NSMenuItem separatorItem] atIndex: index];
+    [impl_->menu_ insertItem:[NSMenuItem separatorItem] atIndex:index];
 }
 
-int MenuMacOS::GetNumberOfItems() const {
-    return impl_->menu_.numberOfItems;
-}
+int MenuMacOS::GetNumberOfItems() const { return impl_->menu_.numberOfItems; }
 
 bool MenuMacOS::IsEnabled(ItemId item_id) const {
     NSMenuItem *item = impl_->FindMenuItem(item_id);
@@ -161,8 +156,7 @@ - (void)run {
 void MenuMacOS::SetChecked(ItemId item_id, bool checked) {
     NSMenuItem *item = impl_->FindMenuItem(item_id);
     if (item) {
-        item.state = (checked ? NSControlStateValueOn
-                              : NSControlStateValueOff);
+        item.state = (checked ? NSControlStateValueOn : NSControlStateValueOff);
     }
 }
 
@@ -170,9 +164,7 @@ - (void)run {
     return 0;  // menu is not part of window on macOS
 }
 
-bool MenuMacOS::CheckVisibilityChange() const {
-    return false;
-}
+bool MenuMacOS::CheckVisibilityChange() const { return false; }
 
 MenuBase::ItemId MenuMacOS::DrawMenuBar(const DrawContext &context,
                                         bool is_enabled) {
diff --git a/cpp/open3d/visualization/gui/NativeMacOS.mm b/cpp/open3d/visualization/gui/NativeMacOS.mm
index 7510ace0110..8856374d39a 100644
--- a/cpp/open3d/visualization/gui/NativeMacOS.mm
+++ b/cpp/open3d/visualization/gui/NativeMacOS.mm
@@ -45,16 +45,18 @@ void MacTransformIntoApp() {
     // that TransformProcessType() needs to be called if we aren't in a bundle.
     // Absent any concrete documentation, we chant the incantation and hope that
     // any side-effects or age-related effects are minimal.
-    ProcessSerialNumber psn = { 0, kCurrentProcess };
+    ProcessSerialNumber psn = {0, kCurrentProcess};
     TransformProcessType(&psn, kProcessTransformToForegroundApplication);
 }
 
 void SetupMetalLayer(void* nativeView) {
-    NSView* view = (NSView*) nativeView;
+    NSView* view = (NSView*)nativeView;
     [view setWantsLayer:YES];
-    [view setLayerContentsRedrawPolicy:NSViewLayerContentsRedrawDuringViewResize];
-    [view setLayerContentsPlacement:NSViewLayerContentsPlacementScaleProportionallyToFill];
-    
+    [view setLayerContentsRedrawPolicy:
+                    NSViewLayerContentsRedrawDuringViewResize];
+    [view setLayerContentsPlacement:
+                    NSViewLayerContentsPlacementScaleProportionallyToFill];
+
     CAMetalLayer* metalLayer = [CAMetalLayer layer];
     metalLayer.bounds = view.bounds;
     metalLayer.frame = NSRectToCGRect(view.frame);
@@ -64,13 +66,14 @@ void SetupMetalLayer(void* nativeView) {
         metalLayer.contentsScale = [NSScreen mainScreen].backingScaleFactor;
     }
 
-    // It's important to set the drawableSize to the actual backing pixels. When rendering
-    // full-screen, we can skip the macOS compositor if the size matches the display size.
+    // It's important to set the drawableSize to the actual backing pixels. When
+    // rendering full-screen, we can skip the macOS compositor if the size
+    // matches the display size.
     metalLayer.drawableSize = [view convertSizeToBacking:view.bounds.size];
 
-    // This is set to NO by default, but is also important to ensure we can bypass the compositor
-    // in full-screen mode
-    // See "Direct to Display" http://metalkit.org/2017/06/30/introducing-metal-2.html.
+    // This is set to NO by default, but is also important to ensure we can
+    // bypass the compositor in full-screen mode See "Direct to Display"
+    // http://metalkit.org/2017/06/30/introducing-metal-2.html.
     metalLayer.opaque = YES;
     [view setLayer:metalLayer];
     // return metalLayer;
@@ -83,7 +86,8 @@ void SetupMetalLayer(void* nativeView) {
 //     if (metalLayer) {
 //         metalLayer.contentsScale = view.window.backingScaleFactor;
 //         metalLayer.frame = NSRectToCGRect(view.frame);
-//         metalLayer.drawableSize = [view convertSizeToBacking:view.bounds.size];
+//         metalLayer.drawableSize = [view
+//         convertSizeToBacking:view.bounds.size];
 //     }
 // }
 
@@ -109,31 +113,31 @@ void PostNativeExposeEvent(GLFWwindow* glfw_window) {
     // This situation does not seem to get triggered by the viewer app.
     if ([win contentView].needsDisplay == YES) {
         dispatch_async(dispatch_get_main_queue(), ^{
-            [win contentView].needsDisplay = YES;
+          [win contentView].needsDisplay = YES;
         });
     } else {
         [win contentView].needsDisplay = YES;
     }
 }
 
-void ShowNativeAlert(const char *message) {
-    NSAlert *alert = [[NSAlert alloc] init];
+void ShowNativeAlert(const char* message) {
+    NSAlert* alert = [[NSAlert alloc] init];
     [alert setMessageText:[NSString stringWithUTF8String:message]];
     [alert runModal];
 }
 
-
 void SetNativeMenubar(void* menubar) {
-    NSMenu *menu = (NSMenu*)menubar;
+    NSMenu* menu = (NSMenu*)menubar;
     NSApplication.sharedApplication.mainMenu = menu;
 }
 
-void ShowNativeFileDialog(FileDialog::Mode type,
-                          const std::string& path,
-                          const std::vector<std::pair<std::string, std::string>>& filters,
-                          std::function<void(const char*)> on_ok,
-                          std::function<void()> on_cancel) {
-    NSSavePanel *dlg; // NSOpenPanel inherits from NSSavePanel, oddly enough
+void ShowNativeFileDialog(
+        FileDialog::Mode type,
+        const std::string& path,
+        const std::vector<std::pair<std::string, std::string>>& filters,
+        std::function<void(const char*)> on_ok,
+        std::function<void()> on_cancel) {
+    NSSavePanel* dlg;  // NSOpenPanel inherits from NSSavePanel, oddly enough
     if (type == FileDialog::Mode::OPEN) {
         NSOpenPanel* open_dlg = [NSOpenPanel openPanel];
         open_dlg.allowsMultipleSelection = NO;
@@ -141,7 +145,7 @@ void ShowNativeFileDialog(FileDialog::Mode type,
         open_dlg.canChooseFiles = YES;
         dlg = open_dlg;
     } else if (type == FileDialog::Mode::OPEN_DIR) {
-        NSOpenPanel *open_dlg = [NSOpenPanel openPanel];
+        NSOpenPanel* open_dlg = [NSOpenPanel openPanel];
         open_dlg.allowsMultipleSelection = NO;
         open_dlg.canChooseDirectories = YES;
         open_dlg.canChooseFiles = NO;
@@ -149,21 +153,28 @@ void ShowNativeFileDialog(FileDialog::Mode type,
     } else {
         dlg = [NSSavePanel savePanel];
     }
-    dlg.directoryURL = [NSURL fileURLWithPath:[NSString stringWithUTF8String:path.c_str()]];
+    dlg.directoryURL = [NSURL
+            fileURLWithPath:[NSString stringWithUTF8String:path.c_str()]];
 
     if (type != FileDialog::Mode::OPEN_DIR) {
-        if (!filters.empty()) {  // [NSMutableArray arrayWidthCapacity:0] returns nil
-            NSMutableArray *allowed = [NSMutableArray arrayWithCapacity:2 * filters.size()];
-            for (auto &f : filters) {
+        if (!filters.empty()) {  // [NSMutableArray arrayWidthCapacity:0]
+                                 // returns nil
+            NSMutableArray* allowed =
+                    [NSMutableArray arrayWithCapacity:2 * filters.size()];
+            for (auto& f : filters) {
                 if (f.first.empty() || f.first == "*.*") {
                     continue;
                 }
-                std::vector<std::string> exts = utility::SplitString(f.first, ", ");
-                for (std::string ext : exts) {  // ext is a copy; might modify it
-                    if (ext[0] == '.') {  // macOS assumes the dot in the extension
+                std::vector<std::string> exts =
+                        utility::SplitString(f.first, ", ");
+                for (std::string ext :
+                     exts) {  // ext is a copy; might modify it
+                    if (ext[0] ==
+                        '.') {  // macOS assumes the dot in the extension
                         ext = ext.substr(1);
                     }
-                    [allowed addObject:[NSString stringWithUTF8String:ext.c_str()]];
+                    [allowed addObject:[NSString stringWithUTF8String:
+                                                         ext.c_str()]];
                 }
             }
             dlg.allowedFileTypes = allowed;
@@ -173,14 +184,14 @@ void ShowNativeFileDialog(FileDialog::Mode type,
         dlg.allowsOtherFileTypes = NO;
     }
 
-    NSWindow *current = NSApp.mainWindow;
+    NSWindow* current = NSApp.mainWindow;
     [dlg beginWithCompletionHandler:^(NSModalResponse result) {
-        if (result == NSModalResponseOK) {
-            on_ok(dlg.URL.path.UTF8String);
-        } else {
-            on_cancel();
-        }
-        [current makeKeyWindow];
+      if (result == NSModalResponseOK) {
+          on_ok(dlg.URL.path.UTF8String);
+      } else {
+          on_cancel();
+      }
+      [current makeKeyWindow];
     }];
 }
 
diff --git a/cpp/open3d/visualization/rendering/MaterialRecord.h b/cpp/open3d/visualization/rendering/MaterialRecord.h
index ef1b174d35a..c3ddbe6261a 100644
--- a/cpp/open3d/visualization/rendering/MaterialRecord.h
+++ b/cpp/open3d/visualization/rendering/MaterialRecord.h
@@ -83,8 +83,29 @@ struct MaterialRecord {
     // Infinite ground plane
     float ground_plane_axis = 0.f;  // 0: XZ; >0: XY; <0: YZ
 
-    // This is only used in gaussian splat.
-    int sh_degree = 0;
+    // Max Spherical Harmonic degree for rendering gaussian splats.
+    int gaussian_splat_sh_degree = 2;
+
+    // Minimum splat alpha value when rendering gaussian splats.
+    /// Minimum alpha threshold for Gaussian splat CPU-side filtering in
+    /// PackGaussianSplatAttrsDirect().  Splats whose sigmoid(opacity) is below
+    /// this value are discarded at load time and never uploaded to the GPU,
+    /// removing the need for a redundant per-splat GPU alpha test.
+    /// Matches the composite pass kMinAlpha = 1/255.
+    float gaussian_splat_min_alpha = 1.0f / 255.0f;
+
+    // Enable anti-aliasing density compensation for gaussian splats.
+    // Multiplies each splat's opacity by sqrt(det(Sigma) / det(Sigma_blurred))
+    // to counteract the over-brightening caused by the fixed +0.3 blur kernel.
+    bool gaussian_splat_antialias = false;
+
+    // Maximum number of screen tiles that a single splat may cover.
+    // Raise this value for very large splats at the cost of higher memory use.
+    uint32_t gaussian_splat_max_tiles_per_splat = 32;
+
+    // Total tile-coverage entry budget for the whole scene.
+    // Raise this for dense or high-resolution scenes at the cost of GPU memory.
+    uint32_t gaussian_splat_max_tile_entries_total = 32u * 1024u * 1024u;
 
     // Generic material properties
     std::unordered_map<std::string, Eigen::Vector4f> generic_params;
diff --git a/cpp/open3d/visualization/rendering/Renderer.h b/cpp/open3d/visualization/rendering/Renderer.h
index 11ef0958f67..c79f78e5748 100644
--- a/cpp/open3d/visualization/rendering/Renderer.h
+++ b/cpp/open3d/visualization/rendering/Renderer.h
@@ -79,6 +79,11 @@ class Renderer {
 
     virtual void SetOnAfterDraw(std::function<void()> callback) = 0;
 
+    /// Returns whether the most recent BeginFrame() accepted a swap-chain
+    /// frame (Filament \c beginFrame returned true). Used for diagnostics;
+    /// defaults to false for backends that do not track this.
+    virtual bool LastBeginFrameSubmitted() const { return false; }
+
     virtual MaterialHandle AddMaterial(const ResourceLoadRequest& request) = 0;
     virtual MaterialInstanceHandle AddMaterialInstance(
             const MaterialHandle& material) = 0;
diff --git a/cpp/open3d/visualization/rendering/View.h b/cpp/open3d/visualization/rendering/View.h
index cd29b6a4df2..f9bb7325dc2 100644
--- a/cpp/open3d/visualization/rendering/View.h
+++ b/cpp/open3d/visualization/rendering/View.h
@@ -80,6 +80,11 @@ class View {
     virtual void EnableViewCaching(bool enable) = 0;
     virtual bool IsCached() const = 0;
     virtual TextureHandle GetColorBuffer() = 0;
+    virtual TextureHandle GetDepthBuffer() = 0;
+
+    /// Returns the Gaussian compute overlay texture (premultiplied alpha),
+    /// or an invalid handle if no compute output is available.
+    virtual TextureHandle GetGaussianSplatOverlay() { return {}; }
 
     virtual Camera* GetCamera() const = 0;
 };
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPU.h b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPU.h
new file mode 100644
index 00000000000..611a1ca17a1
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPU.h
@@ -0,0 +1,424 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+//
+// Generic GPU compute abstraction used by the Gaussian splatting pipeline.
+// One header covers all platforms (OpenGL on Linux/Windows, Metal on macOS).
+// Runtime shader resources are loaded from resources/gaussian_splat/.
+//
+// Typical usage:
+//
+//   // One GpuComputeFrame per geometry or composite stage (RAII).
+//   GpuComputeFrame frame(ctx, GpuComputeFrame::kGeometry);
+//
+//   // Each dispatch: one temporary GpuComputePass expression.
+//   GpuComputePass(ctx, ComputeProgramId::kGsProject, "gs_project")
+//       .UBO(0, view_params_buf)
+//       .SSBO(1, positions_buf)
+//       .Dispatch(groups_x, 1, 1);
+//   ctx.FullBarrier();
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+
+/// Program IDs for the Gaussian splatting compute shaders.
+/// Values index into kGsShaderNames; kCount must stay last.
+enum class ComputeProgramId : int {
+    kGsProject = 0,
+    kGsComposite = 1,
+    kGsRadixHistograms = 2,
+    kGsRadixScatter = 3,
+    kGsDispatchArgs = 4,
+    /// Merges GS linear depth (R32F) with Filament scene depth (reversed-Z)
+    /// into a normalised R16UI texture for CPU readback.
+    kGsDepthMerge = 5,
+    kCount = 6,
+};
+
+/// Format selector for GaussianSplatGpuContext::BindImage().
+enum class ImageFormat { kRGBA16F, kR32F, kR16UI };
+
+/// Canonical shader base names indexed by ComputeProgramId.
+/// Backends append ".spv" (Vulkan) or "_main" (Metal entry point).
+constexpr const char* kGsShaderNames[] = {
+        "gaussian_project",
+        "gaussian_composite",
+        "gaussian_radix_sort_histograms",
+        "gaussian_radix_sort_scatter",
+        "gaussian_compute_dispatch_args",
+        "gaussian_depth_merge",
+};
+static_assert(std::size(kGsShaderNames) ==
+                      static_cast<std::size_t>(ComputeProgramId::kCount),
+              "kGsShaderNames must match ComputeProgramId::kCount");
+
+// ---------------------------------------------------------------------------
+// GPU data layout structs
+// ---------------------------------------------------------------------------
+
+/// Per-radix-pass UBO at binding 14 (std140 layout, matches GPU shader).
+/// Matches the RadixSortParams uniform block in the radix-sort shaders.
+/// Named to match the GLSL block: `layout(std140, binding=14) uniform
+/// RadixSortParams`.
+struct RadixSortParams {
+    std::uint32_t g_num_elements = 0;
+    std::uint32_t g_shift = 0;
+    std::uint32_t g_num_workgroups = 0;
+    std::uint32_t g_num_blocks_per_workgroup = 0;
+};
+static_assert(sizeof(RadixSortParams) == 16,
+              "RadixSortParams must be 16 bytes to match GLSL layout");
+
+/// Per-view GPU resource handles (opaque: GL name or MTLBuffer/MTLTexture).
+struct GaussianSplatViewGpuResources {
+    std::uintptr_t view_params_buf = 0;
+    std::uintptr_t positions_buf = 0;
+    std::uintptr_t scales_buf = 0;
+    std::uintptr_t rotations_buf = 0;
+    std::uintptr_t dc_opacity_buf = 0;
+    std::uintptr_t sh_buf = 0;
+    /// Composite-pass projected data (32 B/splat, binding 6).
+    /// Written by project, read only by composite.
+    std::uintptr_t projected_composite_buf = 0;
+    /// Per-frame work-stealing atomic counter (1 uint32): cleared before each
+    /// composite pass; each composite workgroup atomically claims tile indices.
+    std::uintptr_t tile_counts_buf = 0;
+    /// GPU error/diagnostic counters (total_entries, error_flags, ...).
+    std::uintptr_t counters_buf = 0;
+    std::uintptr_t dispatch_args_buf = 0;
+    /// Ping-pong sort buffers: keys = (tile<<D)|(depth>>T), values =
+    /// splat_index.
+    std::uintptr_t sort_keys_buf[2] = {0, 0};
+    std::uintptr_t sort_values_buf[2] = {0, 0};
+    std::uintptr_t histogram_buf = 0;
+    std::uintptr_t radix_params_buf = 0;
+    /// Bit-packed per-splat visibility mask. Bound at binding 15.
+    std::uintptr_t mask_buf = 0;
+    /// GS composite depth output (image binding 1); not the shared scene depth.
+    std::uintptr_t composite_depth_tex = 0;
+    /// Merged GS+Filament depth as R16UI (normalised [0,65535]); non-zero only
+    /// when an offscreen capture is active and scene depth is available.
+    std::uintptr_t merged_depth_u16_tex = 0;
+    /// Which sort_values_buf index holds the final sorted splat indices.
+    /// Set at the end of RunGaussianGeometryPasses; read by composite.
+    int final_sort_src = 0;
+    std::uint64_t cached_scene_id = 0;
+    std::uint32_t cached_splat_count = 0;
+    std::uint32_t warned_gpu_error_flags = 0;
+};
+
+// ---------------------------------------------------------------------------
+// GaussianSplatGpuContext — abstract GPU backend interface
+// ---------------------------------------------------------------------------
+
+/// Platform-agnostic GPU operations for compute passes.
+/// Implementations: ComputeGPUVulkan (non-Apple) and ComputeGPUMetal (Apple).
+class GaussianSplatGpuContext {
+public:
+    virtual ~GaussianSplatGpuContext() = default;
+
+    /// Load all compute programs (lazy, idempotent).
+    virtual bool EnsureProgramsLoaded() = 0;
+
+    // --- Buffer management ------------------------------------------------
+    virtual std::uintptr_t CreateBuffer(std::size_t size,
+                                        const char* label = nullptr) = 0;
+    virtual void DestroyBuffer(std::uintptr_t buf) = 0;
+    /// Returns a valid handle (may replace buf when the API reallocates).
+    virtual std::uintptr_t ResizeBuffer(std::uintptr_t buf,
+                                        std::size_t new_size,
+                                        const char* label = nullptr) = 0;
+
+    /// GPU-private buffer: never CPU-mapped after creation.
+    /// Metal: MTLStorageModePrivate; OpenGL: GL_DYNAMIC_COPY.
+    virtual std::uintptr_t CreatePrivateBuffer(std::size_t size,
+                                               const char* label = nullptr) {
+        return CreateBuffer(size, label);
+    }
+    virtual std::uintptr_t ResizePrivateBuffer(std::uintptr_t buf,
+                                               std::size_t new_size,
+                                               const char* label = nullptr) {
+        return ResizeBuffer(buf, new_size, label);
+    }
+    virtual void UploadBuffer(std::uintptr_t buf,
+                              const void* data,
+                              std::size_t size,
+                              std::size_t offset) = 0;
+    virtual bool DownloadBuffer(std::uintptr_t buf,
+                                void* dst,
+                                std::size_t size,
+                                std::size_t offset) {
+        (void)buf;
+        (void)dst;
+        (void)size;
+        (void)offset;
+        return false;
+    }
+    virtual void ClearBufferUInt32Zero(std::uintptr_t buf) = 0;
+
+    // --- Bindings ---------------------------------------------------------
+    virtual void BindSSBO(std::uint32_t binding, std::uintptr_t buf) = 0;
+    virtual void BindUBO(std::uint32_t binding, std::uintptr_t buf) = 0;
+    virtual void BindUBORange(std::uint32_t binding,
+                              std::uintptr_t buf,
+                              std::size_t offset,
+                              std::size_t range_size) = 0;
+
+    // --- Dispatch ---------------------------------------------------------
+    virtual void UseProgram(ComputeProgramId id) = 0;
+    virtual void Dispatch(std::uint32_t groups_x,
+                          std::uint32_t groups_y,
+                          std::uint32_t groups_z) = 0;
+    virtual void DispatchIndirect(std::uintptr_t indirect_buf,
+                                  std::size_t byte_offset) = 0;
+    virtual void FullBarrier() = 0;
+
+    /// Maximum compute dispatch group count along the X axis.
+    /// Used to split large dispatches into 2D grids that stay within device
+    /// limits (Vulkan: VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]).
+    /// Default returns 65535 (Vulkan minimum guaranteed by the spec).
+    virtual std::uint32_t GetMaxComputeWorkGroupCount() const { return 65535u; }
+
+    // --- Textures / images ------------------------------------------------
+    virtual std::uintptr_t CreateTexture2DR32F(std::uint32_t width,
+                                               std::uint32_t height,
+                                               const char* label = nullptr) = 0;
+    virtual void DestroyTexture(std::uintptr_t tex) = 0;
+    virtual std::uintptr_t ResizeTexture2DR32F(std::uintptr_t tex,
+                                               std::uint32_t width,
+                                               std::uint32_t height,
+                                               const char* label = nullptr) = 0;
+    /// Create or resize an R16UI texture for merged-depth CPU readback.
+    virtual std::uintptr_t ResizeTexture2DR16UI(
+            std::uintptr_t tex,
+            std::uint32_t width,
+            std::uint32_t height,
+            const char* label = nullptr) = 0;
+
+    /// Download the contents of an R32F texture into a float vector.
+    /// The caller must ensure no outstanding GPU writes to the texture.
+    /// Returns false when not supported or on error.
+    virtual bool DownloadTextureR32F(std::uintptr_t tex,
+                                     std::uint32_t width,
+                                     std::uint32_t height,
+                                     std::vector<float>& out) {
+        (void)tex;
+        (void)width;
+        (void)height;
+        (void)out;
+        return false;
+    }
+
+    /// Download the contents of an R16UI texture into a uint16_t vector.
+    /// The caller must ensure no outstanding GPU writes to the texture.
+    /// Returns false when not supported or on error.
+    virtual bool DownloadTextureR16UI(std::uintptr_t tex,
+                                      std::uint32_t width,
+                                      std::uint32_t height,
+                                      std::vector<std::uint16_t>& out) {
+        (void)tex;
+        (void)width;
+        (void)height;
+        (void)out;
+        return false;
+    }
+
+    /// Bind a write image at the given unit with the specified format.
+    virtual void BindImage(std::uint32_t binding,
+                           std::uintptr_t tex,
+                           std::uint32_t width,
+                           std::uint32_t height,
+                           ImageFormat fmt) = 0;
+
+    virtual void BindSamplerTexture(std::uint32_t unit,
+                                    std::uintptr_t tex,
+                                    std::uint32_t width,
+                                    std::uint32_t height) = 0;
+
+    // --- Frame sync -------------------------------------------------------
+    /// Drain any pending GPU work (GL: glFinish; Metal: no-op, EndCompositePass
+    /// already waits synchronously).
+    virtual void FinishGpuWork() = 0;
+
+    /// Returns whether the most recently submitted GPU work succeeded.
+    virtual bool WasLastSubmitSuccessful() const { return true; }
+
+    /// Metal: wraps each stage in a MTLCommandBuffer + encoder pair.
+    /// Vulkan: manages command buffer lifetime and fence signalling.
+    virtual void BeginGeometryPass() {}
+    virtual void EndGeometryPass() {}
+    virtual void BeginCompositePass() {}
+    virtual void EndCompositePass() {}
+
+    /// Ensure geometry pass GPU work has finished before composite begins.
+    /// Vulkan: CPU-waits on the geometry fence if still pending
+    /// (fire-and-forget geometry overlaps Filament rendering; this drains it
+    /// only if needed). Metal/other: no-op — those backends already wait
+    /// synchronously.
+    virtual void WaitForGeometryPass() {}
+
+    /// KHR_debug / Metal debug-group markers around each dispatch.
+    /// Default implementations are no-ops.
+    virtual void PushDebugGroup(const char* /*label*/) {}
+    virtual void PopDebugGroup() {}
+};
+
+// ---------------------------------------------------------------------------
+// GpuComputeFrame — RAII for Begin/EndGeometryPass or Begin/EndCompositePass
+// ---------------------------------------------------------------------------
+
+/// Wraps BeginGeometryPass()/EndGeometryPass() or the composite equivalents.
+/// Ensures End() is always called even on early-return from a runner function.
+class GpuComputeFrame {
+public:
+    enum Kind { kGeometry, kComposite };
+
+    GpuComputeFrame(GaussianSplatGpuContext& ctx, Kind kind)
+        : ctx_(ctx), kind_(kind) {
+        if (kind_ == kGeometry) {
+            ctx_.BeginGeometryPass();
+        } else {
+            ctx_.BeginCompositePass();
+        }
+    }
+    ~GpuComputeFrame() { End(); }
+
+    GpuComputeFrame(const GpuComputeFrame&) = delete;
+    GpuComputeFrame& operator=(const GpuComputeFrame&) = delete;
+
+    /// Explicitly end the frame early (dtor becomes a no-op).
+    void End() {
+        if (!ended_) {
+            ended_ = true;
+            if (kind_ == kGeometry) {
+                ctx_.EndGeometryPass();
+            } else {
+                ctx_.EndCompositePass();
+            }
+        }
+    }
+
+private:
+    GaussianSplatGpuContext& ctx_;
+    Kind kind_;
+    bool ended_ = false;
+};
+
+// ---------------------------------------------------------------------------
+// GpuComputePass — RAII + builder for a single compute dispatch
+// ---------------------------------------------------------------------------
+
+/// RAII dispatch helper. Ctor: UseProgram + PushDebugGroup.
+/// Builder methods bind resources (return *this for chaining).
+/// Dispatch() / DispatchIndirect() fires the GPU work.
+/// Dtor: PopDebugGroup (if programs loaded successfully).
+///
+/// If EnsureProgramsLoaded() fails, ok() returns false. All builder methods
+/// and dispatch calls become no-ops — caller does NOT need to test ok() unless
+/// it wants to short-circuit further work for the whole pass sequence.
+class GpuComputePass {
+public:
+    GpuComputePass(GaussianSplatGpuContext& ctx,
+                   ComputeProgramId pid,
+                   const char* label = nullptr)
+        : ctx_(ctx), label_(label) {
+        ok_ = ctx_.EnsureProgramsLoaded();
+        if (ok_) {
+            ctx_.UseProgram(pid);
+            if (label_) ctx_.PushDebugGroup(label_);
+        }
+    }
+
+    ~GpuComputePass() {
+        if (ok_ && label_) ctx_.PopDebugGroup();
+    }
+
+    GpuComputePass(const GpuComputePass&) = delete;
+    GpuComputePass& operator=(const GpuComputePass&) = delete;
+
+    /// Returns false only when EnsureProgramsLoaded() failed (device error).
+    [[nodiscard]] bool ok() const { return ok_; }
+
+    // --- Resource binding (fluent builder) --------------------------------
+
+    GpuComputePass& UBO(std::uint32_t binding, std::uintptr_t buf) {
+        if (ok_) ctx_.BindUBO(binding, buf);
+        return *this;
+    }
+
+    GpuComputePass& UBORange(std::uint32_t binding,
+                             std::uintptr_t buf,
+                             std::size_t offset,
+                             std::size_t size) {
+        if (ok_) ctx_.BindUBORange(binding, buf, offset, size);
+        return *this;
+    }
+
+    GpuComputePass& SSBO(std::uint32_t binding, std::uintptr_t buf) {
+        if (ok_) ctx_.BindSSBO(binding, buf);
+        return *this;
+    }
+
+    GpuComputePass& Image(std::uint32_t binding,
+                          std::uintptr_t tex,
+                          std::uint32_t w,
+                          std::uint32_t h,
+                          ImageFormat fmt) {
+        if (ok_) ctx_.BindImage(binding, tex, w, h, fmt);
+        return *this;
+    }
+
+    GpuComputePass& Sampler(std::uint32_t unit,
+                            std::uintptr_t tex,
+                            std::uint32_t w,
+                            std::uint32_t h) {
+        if (ok_) ctx_.BindSamplerTexture(unit, tex, w, h);
+        return *this;
+    }
+
+    // --- Dispatch ---------------------------------------------------------
+
+    void Dispatch(std::uint32_t gx, std::uint32_t gy, std::uint32_t gz) {
+        if (ok_) ctx_.Dispatch(gx, gy, gz);
+    }
+
+    void DispatchIndirect(std::uintptr_t buf, std::size_t byte_offset) {
+        if (ok_) ctx_.DispatchIndirect(buf, byte_offset);
+    }
+
+private:
+    GaussianSplatGpuContext& ctx_;
+    const char* label_;
+    bool ok_;
+};
+
+// ---------------------------------------------------------------------------
+// Factory functions
+// ---------------------------------------------------------------------------
+
+#if !defined(__APPLE__)
+// Vulkan-only: no GL compute factory.
+#endif
+#if defined(__APPLE__)
+[[nodiscard]] std::unique_ptr<GaussianSplatGpuContext>
+CreateComputeGpuContextMetal(std::uintptr_t device_handle,
+                             std::uintptr_t command_queue_handle);
+#endif
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUMetal.mm b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUMetal.mm
new file mode 100644
index 00000000000..36c9c2f8f7d
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUMetal.mm
@@ -0,0 +1,744 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+//
+// Metal implementation of GaussianSplatGpuContext.
+// Compiled only on Apple platforms.
+
+#include "open3d/visualization/rendering/gaussian_splat/ComputeGPU.h"
+
+#if defined(__APPLE__)
+
+#import <Metal/Metal.h>
+
+#include <array>
+#include <cstring>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "open3d/utility/FileSystem.h"
+#include "open3d/utility/Logging.h"
+#include "open3d/visualization/rendering/filament/FilamentEngine.h"
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+namespace {
+
+/// Threads per threadgroup matching GLSL local_size_* in each shader.
+/// Must have exactly ComputeProgramId::kCount rows — enforced by static_assert.
+static const NSUInteger kThreadsPerGroup[][3] = {
+        {64, 1, 1},   // kGsProject
+        {16, 16, 1},  // kGsComposite
+        {256, 1, 1},  // kGsRadixHistograms
+        {256, 1, 1},  // kGsRadixScatter
+        {1, 1, 1},    // kGsDispatchArgs
+        {16, 16, 1},  // kGsDepthMerge
+};
+static_assert(std::size(kThreadsPerGroup) ==
+                      static_cast<std::size_t>(ComputeProgramId::kCount),
+              "kThreadsPerGroup row count must match ComputeProgramId::kCount");
+
+static constexpr std::size_t kMaxBindings = 32;
+
+}  // namespace
+
+class GaussianSplatGpuContextMetal final : public GaussianSplatGpuContext {
+public:
+    GaussianSplatGpuContextMetal(std::uintptr_t device_handle,
+                                 std::uintptr_t queue_handle)
+        : device_((__bridge id<MTLDevice>)reinterpret_cast<void*>(
+                  device_handle)),
+          queue_((__bridge id<MTLCommandQueue>)reinterpret_cast<void*>(
+                  queue_handle)) {}
+
+    ~GaussianSplatGpuContextMetal() override {
+        // Drain any in-flight command buffers. EndCompositePass() already waits
+        // synchronously, so last_submitted_comp_cb_ is complete by the time we
+        // reach the destructor. The wait below is a no-cost safety net.
+        if (encoder_) {
+            [encoder_ endEncoding];
+            encoder_ = nil;
+        }
+        if (geom_cb_) {
+            [geom_cb_ waitUntilCompleted];
+            geom_cb_ = nil;
+        }
+        if (last_submitted_comp_cb_) {
+            [last_submitted_comp_cb_ waitUntilCompleted];
+            last_submitted_comp_cb_ = nil;
+        }
+        for (auto& p : pipelines_) {
+            p = nil;
+        }
+        library_ = nil;
+        sampler_ = nil;
+    }
+
+    bool EnsureProgramsLoaded() override {
+        if (library_) {
+            return true;
+        }
+        const std::string lib_path = EngineInstance::GetResourcePath() +
+                                     "/gaussian_splat/gaussian_splat.metallib";
+        if (!utility::filesystem::FileExists(lib_path)) {
+            utility::LogWarning("Metal: missing metallib at {}", lib_path);
+            return false;
+        }
+        NSString* npath = [NSString stringWithUTF8String:lib_path.c_str()];
+        NSError* err = nil;
+        library_ = [device_ newLibraryWithFile:npath error:&err];
+        if (!library_) {
+            utility::LogWarning(
+                    "Metal: newLibraryWithFile failed: {}",
+                    err ? [[err localizedDescription] UTF8String] : "unknown");
+            return false;
+        }
+
+        auto load_pipeline = [&](int i) -> bool {
+            std::string entry_name = std::string(kGsShaderNames[i]) + "_main";
+            NSString* name = [NSString stringWithUTF8String:entry_name.c_str()];
+            id<MTLFunction> fn = [library_ newFunctionWithName:name];
+            if (!fn) {
+                utility::LogDebug("Metal: missing function {}", entry_name);
+                return false;
+            }
+            NSError* perr = nil;
+            id<MTLComputePipelineState> ps =
+                    [device_ newComputePipelineStateWithFunction:fn
+                                                           error:&perr];
+            if (!ps) {
+                utility::LogDebug(
+                        "Metal: pipeline {} failed: {}", entry_name,
+                        perr ? [[perr localizedDescription] UTF8String] : "?");
+                return false;
+            }
+            pipelines_[i] = ps;
+            return true;
+        };
+
+        for (int i = 0; i < static_cast<int>(ComputeProgramId::kCount); ++i) {
+            if (!load_pipeline(i)) {
+                utility::LogWarning("Metal: failed to load base GS program {}",
+                                    kGsShaderNames[i]);
+                return false;
+            }
+        }
+
+        @autoreleasepool {
+            MTLSamplerDescriptor* sdesc = [[MTLSamplerDescriptor alloc] init];
+            sdesc.minFilter = MTLSamplerMinMagFilterLinear;
+            sdesc.magFilter = MTLSamplerMinMagFilterLinear;
+            sdesc.sAddressMode = MTLSamplerAddressModeClampToEdge;
+            sdesc.tAddressMode = MTLSamplerAddressModeClampToEdge;
+            sampler_ = [device_ newSamplerStateWithDescriptor:sdesc];
+        }
+        return true;
+    }
+
+    std::uintptr_t CreateBuffer(std::size_t size,
+                                const char* label = nullptr) override {
+        return AllocateBuffer(size, MTLResourceStorageModeShared, label);
+    }
+
+    /// GPU-private buffer: not CPU-accessible, optimal for GPU-only
+    /// intermediates.
+    std::uintptr_t CreatePrivateBuffer(std::size_t size,
+                                       const char* label = nullptr) override {
+        return AllocateBuffer(size, MTLResourceStorageModePrivate, label);
+    }
+
+    void DestroyBuffer(std::uintptr_t buf) override {
+        if (buf == 0) {
+            return;
+        }
+        buffer_sizes_.erase(buf);
+        id<MTLBuffer> b =
+                (__bridge_transfer id<MTLBuffer>)reinterpret_cast<void*>(buf);
+        (void)b;
+    }
+
+    std::uintptr_t ResizeBuffer(std::uintptr_t buf,
+                                std::size_t new_size,
+                                const char* label = nullptr) override {
+        return ReallocBuffer(buf, new_size, /*priv=*/false, label);
+    }
+
+    std::uintptr_t ResizePrivateBuffer(std::uintptr_t buf,
+                                       std::size_t new_size,
+                                       const char* label = nullptr) override {
+        return ReallocBuffer(buf, new_size, /*priv=*/true, label);
+    }
+
+    void UploadBuffer(std::uintptr_t buf,
+                      const void* data,
+                      std::size_t size,
+                      std::size_t offset) override {
+        if (!buf || !data || size == 0) {
+            return;
+        }
+        id<MTLBuffer> b = (__bridge id<MTLBuffer>)reinterpret_cast<void*>(buf);
+        std::memcpy(static_cast<char*>([b contents]) + offset, data, size);
+    }
+
+    bool DownloadBuffer(std::uintptr_t buf,
+                        void* dst,
+                        std::size_t size,
+                        std::size_t offset) override {
+        if (!buf || !dst || size == 0) {
+            return false;
+        }
+        auto it = buffer_sizes_.find(buf);
+        if (it == buffer_sizes_.end() || offset + size > it->second) {
+            return false;
+        }
+        id<MTLBuffer> b = (__bridge id<MTLBuffer>)reinterpret_cast<void*>(buf);
+        if ([b storageMode] == MTLStorageModePrivate) {
+            return false;
+        }
+        std::memcpy(dst, static_cast<const char*>([b contents]) + offset, size);
+        return true;
+    }
+
+    void ClearBufferUInt32Zero(std::uintptr_t buf) override {
+        auto it = buffer_sizes_.find(buf);
+        if (it == buffer_sizes_.end()) {
+            return;
+        }
+        id<MTLBuffer> b = (__bridge id<MTLBuffer>)reinterpret_cast<void*>(buf);
+        const NSUInteger size = static_cast<NSUInteger>(it->second);
+
+        // When a compute encoder is active we are inside a pass:
+        // clears must happen on the GPU timeline between dispatches,
+        // not at CPU encode time. Use a blit encoder so the fill
+        // executes at the correct point in the command buffer.
+        id<MTLCommandBuffer> cb = geom_cb_ ? geom_cb_ : comp_cb_;
+        if (encoder_ && cb) {
+            [encoder_ endEncoding];
+            id<MTLBlitCommandEncoder> blit = [cb blitCommandEncoder];
+            [blit fillBuffer:b range:NSMakeRange(0, size) value:0];
+            [blit endEncoding];
+            encoder_ = [cb computeCommandEncoder];
+            ApplyEncoderState();
+            return;
+        }
+
+        // No active pass — CPU memset is safe (before CB commit).
+        std::memset([b contents], 0, it -> second);
+    }
+
+    void BindSSBO(std::uint32_t binding, std::uintptr_t buf) override {
+        id<MTLBuffer> b =
+                buf ? (__bridge id<MTLBuffer>)reinterpret_cast<void*>(buf)
+                    : nil;
+        SetBufferBinding(binding, b, 0);
+    }
+
+    void BindUBO(std::uint32_t binding, std::uintptr_t buf) override {
+        BindSSBO(binding, buf);
+    }
+
+    void BindUBORange(std::uint32_t binding,
+                      std::uintptr_t buf,
+                      std::size_t offset,
+                      std::size_t range_size) override {
+        (void)range_size;
+        id<MTLBuffer> b =
+                buf ? (__bridge id<MTLBuffer>)reinterpret_cast<void*>(buf)
+                    : nil;
+        SetBufferBinding(binding, b, static_cast<NSUInteger>(offset));
+    }
+
+    void UseProgram(ComputeProgramId id) override {
+        current_program_ = static_cast<int>(id);
+        if (!encoder_) {
+            return;
+        }
+        int i = static_cast<int>(id);
+        if (i >= 0 && i < static_cast<int>(ComputeProgramId::kCount)) {
+            [encoder_ setComputePipelineState:pipelines_[i]];
+        }
+    }
+
+    void PushDebugGroup(const char* label) override {
+        if (encoder_) {
+            [encoder_ pushDebugGroup:[NSString stringWithUTF8String:label]];
+        }
+    }
+    void PopDebugGroup() override {
+        if (encoder_) {
+            [encoder_ popDebugGroup];
+        }
+    }
+
+    void Dispatch(std::uint32_t groups_x,
+                  std::uint32_t groups_y,
+                  std::uint32_t groups_z) override {
+        if (!encoder_) {
+            return;
+        }
+        int pi = current_program_;
+        if (pi < 0 || pi >= static_cast<int>(ComputeProgramId::kCount)) {
+            return;
+        }
+        MTLSize tg =
+                MTLSizeMake(kThreadsPerGroup[pi][0], kThreadsPerGroup[pi][1],
+                            kThreadsPerGroup[pi][2]);
+        // dispatchThreads: (Metal 2 / macOS 10.13+) lets the driver handle the
+        // partial last threadgroup automatically; total = workgroup_count *
+        // tpg.
+        MTLSize total = MTLSizeMake(
+                static_cast<NSUInteger>(std::max(1u, groups_x)) * tg.width,
+                static_cast<NSUInteger>(std::max(1u, groups_y)) * tg.height,
+                static_cast<NSUInteger>(std::max(1u, groups_z)) * tg.depth);
+        [encoder_ dispatchThreads:total threadsPerThreadgroup:tg];
+    }
+
+    void DispatchIndirect(std::uintptr_t indirect_buf,
+                          std::size_t byte_offset) override {
+        if (!encoder_ || indirect_buf == 0) {
+            return;
+        }
+        int pi = current_program_;
+        if (pi < 0 || pi >= static_cast<int>(ComputeProgramId::kCount)) {
+            return;
+        }
+        id<MTLBuffer> ib =
+                (__bridge id<MTLBuffer>)reinterpret_cast<void*>(indirect_buf);
+        MTLSize tg =
+                MTLSizeMake(kThreadsPerGroup[pi][0], kThreadsPerGroup[pi][1],
+                            kThreadsPerGroup[pi][2]);
+        [encoder_ dispatchThreadgroupsWithIndirectBuffer:ib
+                                    indirectBufferOffset:byte_offset
+                                   threadsPerThreadgroup:tg];
+    }
+
+    void FullBarrier() override {
+        if (!encoder_) {
+            return;
+        }
+        // memoryBarrierWithScope: available since Metal 2 (macOS 10.14+).
+        // macOS 10.14 is the minimum supported since Xcode 12 dropped 10.13.
+        if (@available(macOS 10.14, *)) {
+            [encoder_ memoryBarrierWithScope:MTLBarrierScopeBuffers |
+                                             MTLBarrierScopeTextures];
+            return;
+        }
+        // Fallback on very old hardware: commit and restart the encoder so all
+        // prior writes are visible to subsequent dispatches.
+        id<MTLCommandBuffer> cb = geom_cb_ ? geom_cb_ : comp_cb_;
+        if (cb) {
+            RestartComputeEncoder(cb, /*restore_state=*/true);
+        }
+    }
+
+    std::uintptr_t CreateTexture2DR32F(std::uint32_t width,
+                                       std::uint32_t height,
+                                       const char* label = nullptr) override {
+        MTLTextureDescriptor* d = [MTLTextureDescriptor
+                texture2DDescriptorWithPixelFormat:MTLPixelFormatR32Float
+                                             width:width
+                                            height:height
+                                         mipmapped:NO];
+        d.usage = MTLTextureUsageShaderRead | MTLTextureUsageShaderWrite;
+        d.storageMode = MTLStorageModePrivate;
+        id<MTLTexture> t = [device_ newTextureWithDescriptor:d];
+        if (!t) {
+            return 0;
+        }
+        if (label && label[0] != '\0') {
+            t.label = [NSString stringWithUTF8String:label];
+        }
+        texture_sizes_[reinterpret_cast<std::uintptr_t>(t)] = {width, height};
+        return reinterpret_cast<std::uintptr_t>((__bridge_retained void*)t);
+    }
+
+    void DestroyTexture(std::uintptr_t tex) override {
+        if (tex == 0) {
+            return;
+        }
+        texture_sizes_.erase(tex);
+        id<MTLTexture> t =
+                (__bridge_transfer id<MTLTexture>)reinterpret_cast<void*>(tex);
+        (void)t;
+    }
+
+    std::uintptr_t ResizeTexture2DR32F(std::uintptr_t tex,
+                                       std::uint32_t width,
+                                       std::uint32_t height,
+                                       const char* label = nullptr) override {
+        if (tex == 0) {
+            return CreateTexture2DR32F(width, height, label);
+        }
+        DestroyTexture(tex);
+        return CreateTexture2DR32F(width, height, label);
+    }
+
+    std::uintptr_t ResizeTexture2DR16UI(std::uintptr_t tex,
+                                        std::uint32_t width,
+                                        std::uint32_t height,
+                                        const char* label = nullptr) override {
+        if (tex != 0) {
+            DestroyTexture(tex);
+        }
+        // Allocate a CPU-visible R16Uint texture for merged depth readback.
+        MTLTextureDescriptor* d = [MTLTextureDescriptor
+                texture2DDescriptorWithPixelFormat:MTLPixelFormatR16Uint
+                                             width:width
+                                            height:height
+                                         mipmapped:NO];
+        d.usage = MTLTextureUsageShaderRead | MTLTextureUsageShaderWrite;
+        d.storageMode = MTLStorageModePrivate;
+        id<MTLTexture> t = [device_ newTextureWithDescriptor:d];
+        if (!t) {
+            return 0;
+        }
+        if (label && label[0] != '\0') {
+            t.label = [NSString stringWithUTF8String:label];
+        }
+        const std::uintptr_t k =
+                reinterpret_cast<std::uintptr_t>((__bridge_retained void*)t);
+        texture_sizes_[k] = {width, height};
+        return k;
+    }
+
+    bool DownloadTextureR32F(std::uintptr_t tex,
+                             std::uint32_t width,
+                             std::uint32_t height,
+                             std::vector<float>& out) override {
+        if (tex == 0 || width == 0 || height == 0) return false;
+        id<MTLTexture> src =
+                (__bridge id<MTLTexture>)reinterpret_cast<void*>(tex);
+        return DownloadTextureImpl(src, width, height, sizeof(float), &out,
+                                   nullptr);
+    }
+
+    bool DownloadTextureR16UI(std::uintptr_t tex,
+                              std::uint32_t width,
+                              std::uint32_t height,
+                              std::vector<std::uint16_t>& out) override {
+        if (tex == 0 || width == 0 || height == 0) return false;
+        id<MTLTexture> src =
+                (__bridge id<MTLTexture>)reinterpret_cast<void*>(tex);
+        return DownloadTextureImpl(src, width, height, sizeof(std::uint16_t),
+                                   nullptr, &out);
+    }
+
+    void BindImage(std::uint32_t binding,
+                   std::uintptr_t tex,
+                   std::uint32_t /*width*/,
+                   std::uint32_t /*height*/,
+                   ImageFormat /*fmt*/) override {
+        // Metal infers format and access from the shader; w/h/fmt are unused.
+        id<MTLTexture> t =
+                tex ? (__bridge id<MTLTexture>)reinterpret_cast<void*>(tex)
+                    : nil;
+        SetTextureBinding(binding, t);
+    }
+
+    void BindSamplerTexture(std::uint32_t unit,
+                            std::uintptr_t tex,
+                            std::uint32_t /*width*/,
+                            std::uint32_t /*height*/) override {
+        id<MTLTexture> t =
+                tex ? (__bridge id<MTLTexture>)reinterpret_cast<void*>(tex)
+                    : nil;
+        SetTextureBinding(unit, t);
+        SetSamplerBinding(unit, sampler_);
+    }
+
+    void FinishGpuWork() override {}  // EndCompositePass() already waits.
+
+    bool WasLastSubmitSuccessful() const override {
+        return last_submit_succeeded_;
+    }
+
+    void BeginGeometryPass() override {
+        EndGeometryPass();
+        last_submit_succeeded_ = true;
+        ResetPassState();
+        geom_cb_ = [queue_ commandBuffer];
+        encoder_ = [geom_cb_ computeCommandEncoder];
+    }
+
+    void EndGeometryPass() override {
+        if (encoder_) {
+            [encoder_ endEncoding];
+            encoder_ = nil;
+        }
+        if (geom_cb_) {
+            // Commit without waiting: the geometry CB and the subsequent
+            // Filament frame CB execute in submission order on the same queue,
+            // so Filament's mesh rendering will not begin until geometry
+            // is complete on the GPU.
+            [geom_cb_ commit];
+            geom_cb_ = nil;
+        }
+    }
+
+    void BeginCompositePass() override {
+        if (encoder_) {
+            [encoder_ endEncoding];
+            encoder_ = nil;
+        }
+        last_submit_succeeded_ = true;
+        ResetPassState();
+        comp_cb_ = [queue_ commandBuffer];
+        encoder_ = [comp_cb_ computeCommandEncoder];
+    }
+
+    void EndCompositePass() override {
+        if (encoder_) {
+            [encoder_ endEncoding];
+            encoder_ = nil;
+        }
+        if (comp_cb_) {
+            id<MTLCommandBuffer> cb = comp_cb_;
+            comp_cb_ = nil;
+            [cb commit];
+            // Block the CPU until the GPU composite finishes — matches the
+            // OpenGL path which calls glFinish() before EndCompositePass().
+            [cb waitUntilCompleted];
+            const bool success = [cb status] != MTLCommandBufferStatusError;
+            last_submit_succeeded_ = success;
+            if (!success) {
+                NSError* err = [cb error];
+                utility::LogWarning(
+                        "Metal composite CB error: {}",
+                        err ? [[err localizedDescription] UTF8String]
+                            : "unknown");
+            }
+            // Keep a strong ref so the destructor's drain is a no-cost wait.
+            last_submitted_comp_cb_ = cb;
+        }
+    }
+
+private:
+    struct BufferBindingState {
+        id<MTLBuffer> buffer = nil;
+        NSUInteger offset = 0;
+        bool is_bound = false;
+    };
+    struct TextureBindingState {
+        id<MTLTexture> texture = nil;
+        bool is_bound = false;
+    };
+    struct SamplerBindingState {
+        id<MTLSamplerState> sampler = nil;
+        bool is_bound = false;
+    };
+
+    // Download a private MTLTexture into a CPU vector using a blit encoder.
+    // Exactly one of f32_out and u16_out must be non-null.
+    bool DownloadTextureImpl(id<MTLTexture> src,
+                             std::uint32_t width,
+                             std::uint32_t height,
+                             std::size_t bytes_per_pixel,
+                             std::vector<float>* f32_out,
+                             std::vector<std::uint16_t>* u16_out) {
+        if (!src || !queue_) return false;
+        const NSUInteger row_bytes =
+                static_cast<NSUInteger>(width) * bytes_per_pixel;
+        const NSUInteger total_bytes = row_bytes * height;
+        // Allocate a shared (CPU-visible) staging buffer.
+        id<MTLBuffer> staging =
+                [device_ newBufferWithLength:total_bytes
+                                     options:MTLResourceStorageModeShared];
+        if (!staging) return false;
+
+        id<MTLCommandBuffer> cb = [queue_ commandBuffer];
+        if (!cb) return false;
+        id<MTLBlitCommandEncoder> blit = [cb blitCommandEncoder];
+        [blit copyFromTexture:src
+                             sourceSlice:0
+                             sourceLevel:0
+                            sourceOrigin:MTLOriginMake(0, 0, 0)
+                              sourceSize:MTLSizeMake(width, height, 1)
+                                toBuffer:staging
+                       destinationOffset:0
+                  destinationBytesPerRow:row_bytes
+                destinationBytesPerImage:total_bytes];
+        [blit endEncoding];
+        [cb commit];
+        [cb waitUntilCompleted];
+
+        const void* ptr = [staging contents];
+        if (!ptr) return false;
+        if (f32_out) {
+            f32_out->resize(static_cast<std::size_t>(width) * height);
+            std::memcpy(f32_out->data(), ptr, total_bytes);
+        } else if (u16_out) {
+            u16_out->resize(static_cast<std::size_t>(width) * height);
+            std::memcpy(u16_out->data(), ptr, total_bytes);
+        }
+        return true;
+    }
+
+    std::uintptr_t AllocateBuffer(std::size_t size,
+                                  MTLResourceOptions opts,
+                                  const char* label) {
+        if (size == 0) {
+            return 0;
+        }
+        id<MTLBuffer> buf = [device_ newBufferWithLength:size options:opts];
+        if (!buf) {
+            return 0;
+        }
+        if (label != nullptr && label[0] != '\0') {
+            [buf setLabel:[NSString stringWithUTF8String:label]];
+        }
+        std::uintptr_t key =
+                reinterpret_cast<std::uintptr_t>((__bridge_retained void*)buf);
+        buffer_sizes_[key] = size;
+        return key;
+    }
+
+    std::uintptr_t ReallocBuffer(std::uintptr_t buf,
+                                 std::size_t new_size,
+                                 bool priv,
+                                 const char* label) {
+        if (new_size == 0) {
+            DestroyBuffer(buf);
+            return 0;
+        }
+        if (buf != 0) {
+            auto it = buffer_sizes_.find(buf);
+            if (it != buffer_sizes_.end() && it->second >= new_size) {
+                if (label != nullptr && label[0] != '\0') {
+                    id<MTLBuffer> existing =
+                            (__bridge id<MTLBuffer>)reinterpret_cast<void*>(
+                                    buf);
+                    [existing setLabel:[NSString stringWithUTF8String:label]];
+                }
+                return buf;
+            }
+        }
+        DestroyBuffer(buf);
+        return priv ? CreatePrivateBuffer(new_size, label)
+                    : CreateBuffer(new_size, label);
+    }
+
+    void ResetPassState() {
+        current_program_ = -1;
+        for (auto& b : buffer_bindings_) b = {};
+        for (auto& t : texture_bindings_) t = {};
+        for (auto& s : sampler_bindings_) s = {};
+    }
+
+    void SetBufferBinding(std::uint32_t binding,
+                          id<MTLBuffer> buffer,
+                          NSUInteger offset) {
+        if (binding < buffer_bindings_.size()) {
+            buffer_bindings_[binding] = {buffer, offset, true};
+        }
+        if (encoder_) {
+            [encoder_ setBuffer:buffer offset:offset atIndex:binding];
+        }
+    }
+
+    void SetTextureBinding(std::uint32_t binding, id<MTLTexture> texture) {
+        if (binding < texture_bindings_.size()) {
+            texture_bindings_[binding] = {texture, true};
+        }
+        if (encoder_) {
+            [encoder_ setTexture:texture atIndex:binding];
+        }
+    }
+
+    void SetSamplerBinding(std::uint32_t binding,
+                           id<MTLSamplerState> sampler_state) {
+        if (binding < sampler_bindings_.size()) {
+            sampler_bindings_[binding] = {sampler_state, true};
+        }
+        if (encoder_) {
+            [encoder_ setSamplerState:sampler_state atIndex:binding];
+        }
+    }
+
+    void ApplyEncoderState() {
+        if (!encoder_) {
+            return;
+        }
+        if (current_program_ >= 0 &&
+            current_program_ < static_cast<int>(ComputeProgramId::kCount)) {
+            [encoder_ setComputePipelineState:pipelines_[current_program_]];
+        }
+        for (std::size_t i = 0; i < buffer_bindings_.size(); ++i) {
+            const auto& b = buffer_bindings_[i];
+            if (b.is_bound) {
+                [encoder_ setBuffer:b.buffer
+                             offset:b.offset
+                            atIndex:static_cast<NSUInteger>(i)];
+            }
+        }
+        for (std::size_t i = 0; i < texture_bindings_.size(); ++i) {
+            const auto& t = texture_bindings_[i];
+            if (t.is_bound) {
+                [encoder_ setTexture:t.texture
+                             atIndex:static_cast<NSUInteger>(i)];
+            }
+        }
+        for (std::size_t i = 0; i < sampler_bindings_.size(); ++i) {
+            const auto& s = sampler_bindings_[i];
+            if (s.is_bound) {
+                [encoder_ setSamplerState:s.sampler
+                                  atIndex:static_cast<NSUInteger>(i)];
+            }
+        }
+    }
+
+    void RestartComputeEncoder(id<MTLCommandBuffer> cb, bool restore_state) {
+        if (!cb) {
+            return;
+        }
+        if (encoder_) {
+            [encoder_ endEncoding];
+        }
+        encoder_ = [cb computeCommandEncoder];
+        if (restore_state) {
+            ApplyEncoderState();
+        }
+    }
+
+    id<MTLDevice> device_;
+    id<MTLCommandQueue> queue_;
+    id<MTLLibrary> library_ = nil;
+    id<MTLComputePipelineState>
+            pipelines_[static_cast<int>(ComputeProgramId::kCount)] = {};
+    id<MTLSamplerState> sampler_ = nil;
+
+    id<MTLCommandBuffer> geom_cb_ = nil;
+    id<MTLCommandBuffer> comp_cb_ = nil;
+    // Tracks the most recently committed composite CB so the destructor can
+    // wait for its completion handler to finish before freeing C++ state.
+    id<MTLCommandBuffer> last_submitted_comp_cb_ = nil;
+    id<MTLComputeCommandEncoder> encoder_ = nil;
+
+    int current_program_ = -1;
+
+    std::array<BufferBindingState, kMaxBindings> buffer_bindings_;
+    std::array<TextureBindingState, kMaxBindings> texture_bindings_;
+    std::array<SamplerBindingState, kMaxBindings> sampler_bindings_;
+
+    bool last_submit_succeeded_ = true;
+    std::unordered_map<std::uintptr_t, std::size_t> buffer_sizes_;
+    std::unordered_map<std::uintptr_t, std::pair<std::uint32_t, std::uint32_t>>
+            texture_sizes_;
+};
+
+std::unique_ptr<GaussianSplatGpuContext> CreateComputeGpuContextMetal(
+        std::uintptr_t device_handle, std::uintptr_t command_queue_handle) {
+    return std::make_unique<GaussianSplatGpuContextMetal>(device_handle,
+                                                          command_queue_handle);
+}
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
+
+#endif  // defined(__APPLE__)
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUVulkan.cpp b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUVulkan.cpp
new file mode 100644
index 00000000000..98dff3b32fc
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUVulkan.cpp
@@ -0,0 +1,1381 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+//
+// Vulkan 1.3 compute backend for GaussianSplatGpuContext.
+// One VkPipeline per ComputeProgramId; per-dispatch bindings pushed via
+// VK_KHR_push_descriptor (no descriptor pool management per frame).
+// VMA handles general buffer and image allocation.
+
+#if !defined(__APPLE__)
+
+#include "open3d/visualization/rendering/gaussian_splat/ComputeGPUVulkan.h"
+
+#include <cassert>
+#include <cstring>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+// vulkan-hpp RAII: dynamic dispatch through the per-object DeviceDispatcher;
+// VK_NO_PROTOTYPES is defined transitively via
+// GaussianSplatVulkanInteropContext.h. The global
+// VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE is defined in
+// GaussianSplatVulkanInteropContext.cpp (exactly once in the program).
+
+// VMA: header-only allocator (implementation in
+// GaussianSplatVulkanInteropContext.cpp).
+#include "open3d/utility/FileSystem.h"
+#include "open3d/utility/Logging.h"
+#include "open3d/visualization/rendering/filament/FilamentEngine.h"
+#include "open3d/visualization/rendering/gaussian_splat/ComputeGPU.h"
+#include "open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.h"
+#include "vk_mem_alloc.hpp"
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+// ---------------------------------------------------------------------------
+// Per-pipeline (per-shader) descriptor set layout descriptor.
+// Declares the exact bindings the shader uses; push descriptors require this.
+// ---------------------------------------------------------------------------
+struct ShaderBindingDesc {
+    std::uint32_t binding;
+    VkDescriptorType type;
+    VkImageLayout
+            image_layout;  // Only for STORAGE_IMAGE / COMBINED_IMAGE_SAMPLER
+};
+
+// Binding tables derived from SPIR-V analysis (spirv-dis) of each compiled
+// shader.  image_layout is VK_IMAGE_LAYOUT_UNDEFINED for buffer bindings.
+//
+// NOTE: out_color in composite uses binding 16 (not 0) to avoid conflicting
+//       with the GaussianViewParams UBO at B0.  depth_merge gs_depth uses 15
+//       so Metal texture/sampler slots stay in 0..15.
+
+static constexpr ShaderBindingDesc kBindingsProject[] = {
+        {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {5, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {8, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {10, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {15, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+};
+static constexpr ShaderBindingDesc kBindingsComposite[] = {
+        {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_IMAGE_LAYOUT_GENERAL},
+        {6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {8, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {10, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {11, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {14, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL},
+        {16, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_IMAGE_LAYOUT_GENERAL},
+};
+static constexpr ShaderBindingDesc kBindingsRadixHistograms[] = {
+        {0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {14, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+};
+static constexpr ShaderBindingDesc kBindingsRadixScatter[] = {
+        {0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {14, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+};
+static constexpr ShaderBindingDesc kBindingsDispatchArgs[] = {
+        {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {10, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {11, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {12, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+};
+static constexpr ShaderBindingDesc kBindingsDepthMerge[] = {
+        {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_IMAGE_LAYOUT_UNDEFINED},
+        {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_IMAGE_LAYOUT_GENERAL},
+        {14, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL},
+        {15, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+         VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL},
+};
+
+// Table indexed by ComputeProgramId: binding descriptor + count.
+struct ShaderBindingTable {
+    const ShaderBindingDesc* descs;
+    std::uint32_t count;
+};
+
+static constexpr ShaderBindingTable kShaderBindings[] = {
+        {kBindingsProject, std::size(kBindingsProject)},
+        {kBindingsComposite, std::size(kBindingsComposite)},
+        {kBindingsRadixHistograms, std::size(kBindingsRadixHistograms)},
+        {kBindingsRadixScatter, std::size(kBindingsRadixScatter)},
+        {kBindingsDispatchArgs, std::size(kBindingsDispatchArgs)},
+        {kBindingsDepthMerge, std::size(kBindingsDepthMerge)},
+};
+static_assert(std::size(kShaderBindings) ==
+                      static_cast<std::size_t>(ComputeProgramId::kCount),
+              "kShaderBindings must match ComputeProgramId::kCount");
+
+// ---------------------------------------------------------------------------
+// Vulkan compute backend class
+// ---------------------------------------------------------------------------
+class GaussianSplatGpuContextVulkan final : public GaussianSplatGpuContext {
+public:
+    GaussianSplatGpuContextVulkan() = default;
+
+    ~GaussianSplatGpuContextVulkan() override { Shutdown(); }
+
+    // --- Program management -----------------------------------------------
+
+    bool EnsureProgramsLoaded() override {
+        if (programs_loaded_) return programs_valid_;
+        programs_loaded_ = true;
+        programs_valid_ = false;
+
+        auto& interop = GaussianSplatVulkanInteropContext::GetInstance();
+        if (!interop.IsValid()) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: interop context not initialized");
+            return false;
+        }
+
+        device_ = interop.GetDevice();
+        physical_device_ = interop.GetPhysicalDevice();
+        compute_queue_ = interop.GetComputeQueue();
+        queue_family_ = interop.GetComputeQueueFamily();
+        debug_utils_enabled_ = interop.GetDebugUtilsEnabled();
+
+        if (!InitVma()) return false;
+        if (!InitCommandPool()) return false;
+        if (!InitFence()) return false;
+        if (!InitSampler()) return false;
+
+        // Shaders are compiled with -V --target-env vulkan1.3 by
+        // open3d_add_compute_shaders.
+        const std::string shader_root =
+                EngineInstance::GetResourcePath() + "/gaussian_splat/";
+
+        for (int i = 0; i < static_cast<int>(ComputeProgramId::kCount); ++i) {
+            if (!LoadShader(static_cast<ComputeProgramId>(i), shader_root)) {
+                utility::LogWarning(
+                        "GaussianSplatVulkan: failed to load shader {}",
+                        kGsShaderNames[i]);
+                return false;
+            }
+        }
+        programs_valid_ = true;
+        // Cache the device's maximum compute workgroup count along X so
+        // PassRunner can split large dispatches without hardcoding 65535.
+        // Use vkGetPhysicalDeviceProperties2 (Vulkan 1.1+) to avoid the
+        // legacy-command validation warning triggered by the v1.0 variant.
+        VkPhysicalDeviceProperties2 props2{};
+        props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+        VULKAN_HPP_DEFAULT_DISPATCHER.vkGetPhysicalDeviceProperties2(
+                physical_device_, &props2);
+        max_wg_count_x_ = props2.properties.limits.maxComputeWorkGroupCount[0];
+        utility::LogDebug("GaussianSplatVulkan: programs loaded");
+        return true;
+    }
+
+    std::uint32_t GetMaxComputeWorkGroupCount() const override {
+        // Returns the cached value queried at program-load time.
+        // Falls back to the Vulkan-mandated minimum (65535) if not yet loaded.
+        return max_wg_count_x_ > 0 ? max_wg_count_x_ : 65535u;
+    }
+
+    // --- Buffer management ------------------------------------------------
+
+    std::uintptr_t CreateBuffer(std::size_t size,
+                                const char* label = nullptr) override {
+        return AllocBuf(size, false, label);
+    }
+
+    std::uintptr_t CreatePrivateBuffer(std::size_t size,
+                                       const char* label = nullptr) override {
+        return AllocBuf(size, true, label);
+    }
+
+    void DestroyBuffer(std::uintptr_t buf) override {
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return;
+        auto& e = it->second;
+        // Persistent-mapped allocations (CPU_TO_GPU +
+        // VMA_ALLOCATION_CREATE_MAPPED_BIT) are managed by VMA internally; do
+        // NOT call vmaUnmapMemory on them. vmaDestroyBuffer handles cleanup
+        // including the persistent mapping.
+        vmaDestroyBuffer(vma_, e.buffer, e.alloc);
+        buffers_.erase(it);
+    }
+
+    std::uintptr_t ResizeBuffer(std::uintptr_t buf,
+                                std::size_t new_size,
+                                const char* label = nullptr) override {
+        if (buf == 0) return CreateBuffer(new_size, label);
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return CreateBuffer(new_size, label);
+        if (it->second.size == new_size) return buf;
+        DestroyBuffer(buf);
+        return CreateBuffer(new_size, label);
+    }
+
+    std::uintptr_t ResizePrivateBuffer(std::uintptr_t buf,
+                                       std::size_t new_size,
+                                       const char* label = nullptr) override {
+        if (new_size == 0) {
+            DestroyBuffer(buf);
+            return 0;
+        }
+        if (buf == 0) return CreatePrivateBuffer(new_size, label);
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return CreatePrivateBuffer(new_size, label);
+        if (it->second.size == new_size) return buf;
+        DestroyBuffer(buf);
+        return CreatePrivateBuffer(new_size, label);
+    }
+
+    void UploadBuffer(std::uintptr_t buf,
+                      const void* data,
+                      std::size_t size,
+                      std::size_t offset) override {
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return;
+        auto& e = it->second;
+        void* mapped = e.mapped;
+        if (!mapped) {
+            if (vmaMapMemory(vma_, e.alloc, &mapped) != VK_SUCCESS) return;
+        }
+        std::memcpy(static_cast<char*>(mapped) + offset, data, size);
+        if (!e.mapped) {
+            vmaFlushAllocation(vma_, e.alloc, offset, size);
+            vmaUnmapMemory(vma_, e.alloc);
+        }
+    }
+
+    bool DownloadBuffer(std::uintptr_t buf,
+                        void* dst,
+                        std::size_t size,
+                        std::size_t offset) override {
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return false;
+        auto& e = it->second;
+        if (e.is_private) return false;
+        void* mapped = e.mapped;
+        if (!mapped) {
+            if (vmaMapMemory(vma_, e.alloc, &mapped) != VK_SUCCESS)
+                return false;
+        }
+        vmaInvalidateAllocation(vma_, e.alloc, offset, size);
+        std::memcpy(dst, static_cast<const char*>(mapped) + offset, size);
+        if (!e.mapped) vmaUnmapMemory(vma_, e.alloc);
+        return true;
+    }
+
+    void ClearBufferUInt32Zero(std::uintptr_t buf) override {
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return;
+        cmd_.fillBuffer(vk::Buffer(it->second.buffer), 0, VK_WHOLE_SIZE, 0u);
+    }
+
+    // --- Bindings ---------------------------------------------------------
+
+    void BindSSBO(std::uint32_t binding, std::uintptr_t buf) override {
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return;
+        PendingWrite pw{};
+        pw.binding = binding;
+        pw.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+        pw.buf = {it->second.buffer, 0, VK_WHOLE_SIZE};
+        pending_.push_back(pw);
+    }
+
+    void BindUBO(std::uint32_t binding, std::uintptr_t buf) override {
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return;
+        PendingWrite pw{};
+        pw.binding = binding;
+        pw.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+        pw.buf = {it->second.buffer, 0, it->second.size};
+        pending_.push_back(pw);
+    }
+
+    void BindUBORange(std::uint32_t binding,
+                      std::uintptr_t buf,
+                      std::size_t offset,
+                      std::size_t range_size) override {
+        auto it = buffers_.find(buf);
+        if (it == buffers_.end()) return;
+        PendingWrite pw{};
+        pw.binding = binding;
+        pw.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+        pw.buf = {it->second.buffer, offset, range_size};
+        pending_.push_back(pw);
+    }
+
+    void BindImage(std::uint32_t binding,
+                   std::uintptr_t tex,
+                   std::uint32_t /*width*/,
+                   std::uint32_t /*height*/,
+                   ImageFormat /*fmt*/) override {
+        // Depth images (D32_SFLOAT) lack VK_IMAGE_USAGE_STORAGE_BIT and
+        // cannot be bound as STORAGE_IMAGE.  This indicates a caller bug
+        // (wrong handle); skip silently so we don't trigger VUID-00339.
+        auto it = textures_.find(tex);
+        if (it == textures_.end()) {
+            auto git = gl_to_handle_.find(static_cast<std::uint32_t>(tex));
+            if (git != gl_to_handle_.end()) {
+                it = textures_.find(git->second);
+            }
+        }
+        if (it != textures_.end() &&
+            it->second.format == VK_FORMAT_D32_SFLOAT) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: BindImage(binding={}) skipped — "
+                    "handle resolves to a depth image which cannot be a "
+                    "STORAGE_IMAGE. Check handle/GL-name mapping.",
+                    binding);
+            return;
+        }
+        auto view = ResolveImageView(tex, VK_IMAGE_LAYOUT_GENERAL);
+        if (view == VK_NULL_HANDLE) return;
+        PendingWrite pw{};
+        pw.binding = binding;
+        pw.type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+        pw.img = {VK_NULL_HANDLE, view, VK_IMAGE_LAYOUT_GENERAL};
+        pending_.push_back(pw);
+    }
+
+    void BindSamplerTexture(std::uint32_t unit,
+                            std::uintptr_t tex,
+                            std::uint32_t /*width*/,
+                            std::uint32_t /*height*/) override {
+        auto view =
+                ResolveImageView(tex, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+        if (view == VK_NULL_HANDLE) return;
+        PendingWrite pw{};
+        pw.binding = unit;
+        pw.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+        pw.img = {static_cast<VkSampler>(*nearest_sampler_), view,
+                  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL};
+        pending_.push_back(pw);
+    }
+
+    // --- Dispatch ---------------------------------------------------------
+
+    void UseProgram(ComputeProgramId id) override {
+        int i = static_cast<int>(id);
+        if (i < 0 || i >= static_cast<int>(ComputeProgramId::kCount)) return;
+        auto& p = pipelines_[i];
+        if (!p.valid) return;
+        active_id_ = i;
+        cmd_.bindPipeline(vk::PipelineBindPoint::eCompute, *p.pipeline);
+        pending_.clear();
+    }
+
+    void Dispatch(std::uint32_t gx,
+                  std::uint32_t gy,
+                  std::uint32_t gz) override {
+        FlushPendingBindings();
+        cmd_.dispatch(gx, gy, gz);
+    }
+
+    void DispatchIndirect(std::uintptr_t indirect_buf,
+                          std::size_t byte_offset) override {
+        auto it = buffers_.find(indirect_buf);
+        if (it == buffers_.end()) return;
+        FlushPendingBindings();
+        cmd_.dispatchIndirect(vk::Buffer(it->second.buffer),
+                              static_cast<vk::DeviceSize>(byte_offset));
+    }
+
+    void FullBarrier() override {
+        // Full compute+transfer memory barrier using Vulkan 1.3
+        // synchronization2.
+        vk::MemoryBarrier2 mb{
+                vk::PipelineStageFlagBits2::eComputeShader |
+                        vk::PipelineStageFlagBits2::eTransfer,
+                vk::AccessFlagBits2::eMemoryWrite,
+                vk::PipelineStageFlagBits2::eComputeShader |
+                        vk::PipelineStageFlagBits2::eTransfer |
+                        vk::PipelineStageFlagBits2::eDrawIndirect,
+                vk::AccessFlagBits2::eMemoryRead |
+                        vk::AccessFlagBits2::eMemoryWrite |
+                        vk::AccessFlagBits2::eIndirectCommandRead,
+        };
+        cmd_.pipelineBarrier2(vk::DependencyInfo{{}, mb, {}, {}});
+    }
+
+    // --- Textures / images ------------------------------------------------
+
+    std::uintptr_t CreateTexture2DR32F(std::uint32_t w,
+                                       std::uint32_t h,
+                                       const char* /*label*/) override {
+        return AllocTex(w, h, VK_FORMAT_R32_SFLOAT,
+                        VK_IMAGE_USAGE_STORAGE_BIT |
+                                VK_IMAGE_USAGE_SAMPLED_BIT |
+                                VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+                        VK_IMAGE_ASPECT_COLOR_BIT);
+    }
+
+    void DestroyTexture(std::uintptr_t tex) override {
+        auto it = textures_.find(tex);
+        if (it == textures_.end()) return;
+        auto& e = it->second;
+        // Explicitly destroy the view before the VMA image for correct order.
+        e.view = vk::raii::ImageView{nullptr};
+        if (!e.is_shared) vmaDestroyImage(vma_, e.image, e.alloc);
+        textures_.erase(it);
+    }
+
+    std::uintptr_t ResizeTexture2DR32F(std::uintptr_t tex,
+                                       std::uint32_t w,
+                                       std::uint32_t h,
+                                       const char* label) override {
+        if (tex == 0) return CreateTexture2DR32F(w, h, label);
+        auto it = textures_.find(tex);
+        if (it != textures_.end() && it->second.width == w &&
+            it->second.height == h)
+            return tex;
+        DestroyTexture(tex);
+        return CreateTexture2DR32F(w, h, label);
+    }
+
+    std::uintptr_t ResizeTexture2DR16UI(std::uintptr_t tex,
+                                        std::uint32_t w,
+                                        std::uint32_t h,
+                                        const char* /*label*/) override {
+        if (tex != 0) {
+            auto it = textures_.find(tex);
+            if (it != textures_.end() && it->second.width == w &&
+                it->second.height == h)
+                return tex;
+            DestroyTexture(tex);
+        }
+        return AllocTex(
+                w, h, VK_FORMAT_R16_UINT,
+                VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+                VK_IMAGE_ASPECT_COLOR_BIT);
+    }
+
+    bool DownloadTextureR32F(std::uintptr_t tex,
+                             std::uint32_t w,
+                             std::uint32_t h,
+                             std::vector<float>& out) override {
+        return DownloadTexBytes(tex, w, h, sizeof(float), out);
+    }
+
+    bool DownloadTextureR16UI(std::uintptr_t tex,
+                              std::uint32_t w,
+                              std::uint32_t h,
+                              std::vector<std::uint16_t>& out) override {
+        return DownloadTexBytes(tex, w, h, sizeof(std::uint16_t), out);
+    }
+
+    // --- Frame boundary ---------------------------------------------------
+
+    void BeginGeometryPass() override { BeginCmdBuf(); }
+    // Fire-and-forget: submit and signal the fence but do NOT block.
+    // Filament rendering proceeds in parallel; WaitForGeometryPass() (called
+    // at the start of RunGaussianCompositePass) drains it only if needed.
+    void EndGeometryPass() override { SubmitOnly(); }
+    void BeginCompositePass() override {
+        BeginCmdBuf();
+        // Acquire shared GL-interop images from the external (OpenGL) API into
+        // this Vulkan compute queue.  flushAndWait() in FilamentRenderer
+        // ensures GL has finished writing before we reach here on the CPU;
+        // these barriers perform the GPU-side queue-family ownership transfer
+        // and set the layout Vulkan will use.  Without them the spec considers
+        // the image contents and layout undefined, which manifests as
+        // VK_ERROR_DEVICE_LOST on strict drivers (typically Windows AMD/Intel).
+        EmitSharedInteropAcquireBarriers();
+    }
+    void EndCompositePass() override {
+        // Release shared images back to the external (OpenGL) API before
+        // Filament samples the GS color overlay.  The release barrier transfers
+        // queue-family ownership and leaves both images in GENERAL so GL can
+        // use them without an explicit Vulkan layout.
+        EmitSharedInteropReleaseBarriers();
+        SubmitAndWait();
+    }
+
+    void WaitForGeometryPass() override { WaitForPendingSubmit(); }
+
+    void FinishGpuWork() override {
+        if (!cmd_active_) return;
+        SubmitAndWait();
+    }
+
+    void PushDebugGroup(const char* label) override {
+        if (!cmd_active_) return;
+        if (!debug_utils_enabled_) return;
+        auto fn = VULKAN_HPP_DEFAULT_DISPATCHER.vkCmdBeginDebugUtilsLabelEXT;
+        if (!fn) return;
+        VkDebugUtilsLabelEXT info{};
+        info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
+        info.pLabelName = label;
+        fn(static_cast<VkCommandBuffer>(*cmd_), &info);
+    }
+    void PopDebugGroup() override {
+        if (!cmd_active_) return;
+        if (!debug_utils_enabled_) return;
+        auto fn = VULKAN_HPP_DEFAULT_DISPATCHER.vkCmdEndDebugUtilsLabelEXT;
+        if (fn) fn(static_cast<VkCommandBuffer>(*cmd_));
+    }
+
+    // --- Shared-image registration (called by GaussianSplatVulkanBackend) -
+
+    void RegisterSharedImage(std::uint32_t gl_name,
+                             VkImage image,
+                             VkFormat format,
+                             std::uint32_t w,
+                             std::uint32_t h) {
+        // If already registered, clean up old data first.
+        UnregisterSharedImage(gl_name);
+        VkImageAspectFlags aspect = (format == VK_FORMAT_D32_SFLOAT)
+                                            ? VK_IMAGE_ASPECT_DEPTH_BIT
+                                            : VK_IMAGE_ASPECT_COLOR_BIT;
+        vk::raii::ImageView view = CreateImageView(image, format, aspect);
+        if (static_cast<VkImageView>(*view) == VK_NULL_HANDLE) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: failed to create view for shared "
+                    "gl_name={}",
+                    gl_name);
+            return;
+        }
+        TexEntry e{};
+        e.image = image;
+        e.view = std::move(view);
+        e.alloc = VK_NULL_HANDLE;  // owned by VulkanInteropContext
+        e.format = format;
+        e.width = w;
+        e.height = h;
+        // Initialise current_layout to GENERAL as a consistent sentinel for
+        // shared images.  The acquire barrier in
+        // EmitSharedInteropAcquireBarriers always uses oldLayout = UNDEFINED
+        // (external-acquire pattern, spec §12.7.4) and ignores this field; the
+        // release barrier writes GENERAL back here each frame.  The sentinel is
+        // used only by ResolveImageView for any intra-CB transitions that
+        // follow the acquire.
+        e.current_layout = VK_IMAGE_LAYOUT_GENERAL;
+        e.is_shared = true;
+        uintptr_t handle = next_handle_++;
+        textures_[handle] = std::move(e);
+        gl_to_handle_[gl_name] = handle;
+    }
+
+    void UnregisterSharedImage(std::uint32_t gl_name) {
+        auto it = gl_to_handle_.find(gl_name);
+        if (it == gl_to_handle_.end()) return;
+        uintptr_t h = it->second;
+        auto te = textures_.find(h);
+        if (te != textures_.end()) {
+            // vk::raii::ImageView in TexEntry auto-destroyed on erase
+            textures_.erase(te);
+        }
+        gl_to_handle_.erase(it);
+    }
+
+private:
+    // --- GL–Vulkan interop barriers ----------------------------------------
+
+    // Emit image memory barriers that acquire ownership of every shared
+    // (GL-interop) image from VK_QUEUE_FAMILY_EXTERNAL to this compute queue.
+    //
+    // These barriers must be the first commands in the composite command buffer
+    // (called from BeginCompositePass after BeginCmdBuf).  On the GL side,
+    // engine_.flushAndWait() already guarantees GPU completion before this CB
+    // records, so srcStageMask = NONE / srcAccessMask = 0 is correct: we are
+    // not waiting for in-flight Vulkan work but performing an ownership handoff
+    // from an external API whose completion has been ensured by the CPU wait.
+    //
+    // Preserve externally produced contents by acquiring from GENERAL, which
+    // matches the layout we release to at the end of the previous composite
+    // pass. newLayout is chosen to match the first Vulkan use in the composite
+    // pass:
+    //   Color (RGBA16F) -> GENERAL                  (storage image, write/read)
+    //   Depth (D32_SFLOAT) -> SHADER_READ_ONLY_OPTIMAL (combined sampler)
+    // current_layout is updated so ResolveImageView will not emit a redundant
+    // transition on its first call in the same CB.
+    void EmitSharedInteropAcquireBarriers() {
+        std::vector<vk::ImageMemoryBarrier2> barriers;
+        barriers.reserve(textures_.size());
+        for (auto& [handle, e] : textures_) {
+            if (!e.is_shared) continue;
+            const bool is_depth = (e.format == VK_FORMAT_D32_SFLOAT);
+            const vk::ImageLayout new_layout =
+                    is_depth ? vk::ImageLayout::eShaderReadOnlyOptimal
+                             : vk::ImageLayout::eGeneral;
+            const vk::AccessFlags2 dst_access =
+                    is_depth ? vk::AccessFlagBits2::eShaderRead
+                             : (vk::AccessFlagBits2::eShaderRead |
+                                vk::AccessFlagBits2::eShaderWrite);
+            const vk::ImageAspectFlags aspect =
+                    is_depth ? vk::ImageAspectFlagBits::eDepth
+                             : vk::ImageAspectFlagBits::eColor;
+            barriers.emplace_back(
+                    vk::PipelineStageFlagBits2::eNone,  // srcStageMask
+                    vk::AccessFlags2{},                 // srcAccessMask
+                    vk::PipelineStageFlagBits2::eComputeShader,  // dstStageMask
+                    dst_access,
+                    vk::ImageLayout::eGeneral,  // oldLayout (preserve data)
+                    new_layout,
+                    VK_QUEUE_FAMILY_EXTERNAL,  // srcQueueFamilyIndex
+                    queue_family_,             // dstQueueFamilyIndex
+                    vk::Image(e.image),
+                    vk::ImageSubresourceRange{aspect, 0, 1, 0, 1});
+            e.current_layout = static_cast<VkImageLayout>(new_layout);
+        }
+        if (!barriers.empty()) {
+            cmd_.pipelineBarrier2(vk::DependencyInfo{{}, {}, {}, barriers});
+        }
+    }
+
+    // Emit image memory barriers that release ownership of every shared
+    // (GL-interop) image from this compute queue back to
+    // VK_QUEUE_FAMILY_EXTERNAL.
+    //
+    // Called from EndCompositePass just before SubmitAndWait().  After submit
+    // the fence signals on the CPU; Filament then reads the GS color overlay.
+    //
+    // Both images are transitioned to GENERAL for GL (GL has no Vulkan layout
+    // concept; GENERAL is universally compatible with external API hand-off).
+    // current_layout is updated to GENERAL so the next frame's acquire starts
+    // from a consistent sentinel.
+    void EmitSharedInteropReleaseBarriers() {
+        if (!cmd_active_) return;
+        std::vector<vk::ImageMemoryBarrier2> barriers;
+        barriers.reserve(textures_.size());
+        for (auto& [handle, e] : textures_) {
+            if (!e.is_shared) continue;
+            const bool is_depth = (e.format == VK_FORMAT_D32_SFLOAT);
+            const vk::AccessFlags2 src_access =
+                    is_depth ? vk::AccessFlagBits2::eShaderRead
+                             : (vk::AccessFlagBits2::eShaderRead |
+                                vk::AccessFlagBits2::eShaderWrite);
+            const vk::ImageAspectFlags aspect =
+                    is_depth ? vk::ImageAspectFlagBits::eDepth
+                             : vk::ImageAspectFlagBits::eColor;
+            barriers.emplace_back(
+                    vk::PipelineStageFlagBits2::eComputeShader,  // srcStageMask
+                    src_access,
+                    vk::PipelineStageFlagBits2::eNone,  // dstStageMask
+                    vk::AccessFlags2{},                 // dstAccessMask
+                    vk::ImageLayout(
+                            e.current_layout),  // oldLayout (post-composite)
+                    vk::ImageLayout::eGeneral,  // newLayout for GL
+                    queue_family_,              // srcQueueFamilyIndex
+                    VK_QUEUE_FAMILY_EXTERNAL,   // dstQueueFamilyIndex
+                    vk::Image(e.image),
+                    vk::ImageSubresourceRange{aspect, 0, 1, 0, 1});
+            e.current_layout = VK_IMAGE_LAYOUT_GENERAL;
+        }
+        if (!barriers.empty()) {
+            cmd_.pipelineBarrier2(vk::DependencyInfo{{}, {}, {}, barriers});
+        }
+    }
+
+    // --- Internal state ---------------------------------------------------
+    VkDevice device_ = VK_NULL_HANDLE;
+    VkPhysicalDevice physical_device_ = VK_NULL_HANDLE;
+    VkQueue compute_queue_ = VK_NULL_HANDLE;
+    std::uint32_t queue_family_ = 0;
+    VmaAllocator vma_ = VK_NULL_HANDLE;
+    vk::raii::CommandPool cmd_pool_{nullptr};
+    vk::raii::CommandBuffer cmd_{nullptr};
+    vk::raii::Fence fence_{nullptr};
+    vk::raii::Sampler nearest_sampler_{nullptr};
+    bool cmd_active_ = false;
+    bool fence_submitted_ = false;  // true while fence has a pending submission
+
+    struct Pipeline {
+        vk::raii::DescriptorSetLayout dset_layout{nullptr};
+        vk::raii::PipelineLayout layout{nullptr};
+        vk::raii::Pipeline pipeline{nullptr};
+        bool valid = false;
+        // Bitmask of valid bindings so we can filter writes.
+        std::uint64_t binding_mask = 0;  // bit i set ↔ binding i exists
+    };
+    Pipeline pipelines_[static_cast<int>(ComputeProgramId::kCount)];
+    int active_id_ = -1;
+
+    struct BufEntry {
+        VmaAllocation alloc = VK_NULL_HANDLE;
+        VkBuffer buffer = VK_NULL_HANDLE;
+        std::size_t size = 0;
+        void* mapped = nullptr;
+        bool is_private = false;
+    };
+    std::unordered_map<uintptr_t, BufEntry> buffers_;
+
+    struct TexEntry {
+        VmaAllocation alloc = VK_NULL_HANDLE;
+        VkImage image = VK_NULL_HANDLE;
+        vk::raii::ImageView view{
+                nullptr};  // RAII: auto-destroys vkDestroyImageView
+        VkFormat format = VK_FORMAT_UNDEFINED;
+        std::uint32_t width = 0;
+        std::uint32_t height = 0;
+        VkImageLayout current_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+        bool is_shared = false;
+    };
+    std::unordered_map<uintptr_t, TexEntry> textures_;
+    std::unordered_map<std::uint32_t, uintptr_t> gl_to_handle_;
+    // Start at a large value so internal handles never collide with small GL
+    // texture names (which are assigned by the driver starting at 1).
+    std::uint64_t next_handle_ = 0x80000000ULL;
+
+    struct PendingWrite {
+        std::uint32_t binding = 0;
+        VkDescriptorType type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+        VkDescriptorBufferInfo buf{};
+        VkDescriptorImageInfo img{};
+    };
+    std::vector<PendingWrite> pending_;
+
+    bool programs_loaded_ = false;
+    bool programs_valid_ = false;
+    std::uint32_t max_wg_count_x_ = 0;  // cached from VkPhysicalDeviceLimits
+    bool debug_utils_enabled_ =
+            false;  // VK_EXT_debug_utils enabled at instance
+
+    // --- Init helpers -----------------------------------------------------
+
+    bool InitVma() {
+        // VMA is compiled with VMA_STATIC_VULKAN_FUNCTIONS=0 and
+        // VMA_DYNAMIC_VULKAN_FUNCTIONS=0 (set in
+        // GaussianSplatVulkanInteropContext.cpp before VMA_IMPLEMENTATION), so
+        // all function pointers must be provided manually.
+        // vma::functionsFromDispatcher() fills VmaVulkanFunctions from the
+        // vulkan-hpp dynamic dispatcher, which is fully initialised after
+        // GaussianSplatVulkanInteropContext::Initialize() calls
+        // VULKAN_HPP_DEFAULT_DISPATCHER.init(instance) and .init(device).
+        VmaVulkanFunctions vk_fn =
+                vma::functionsFromDispatcher(VULKAN_HPP_DEFAULT_DISPATCHER);
+
+        VmaAllocatorCreateInfo ci{};
+        ci.vulkanApiVersion = VK_API_VERSION_1_3;
+        ci.physicalDevice = physical_device_;
+        ci.device = device_;
+        ci.instance = GaussianSplatVulkanInteropContext::GetInstance()
+                              .GetVkInstance();
+        ci.pVulkanFunctions = &vk_fn;
+        if (vmaCreateAllocator(&ci, &vma_) != VK_SUCCESS) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vmaCreateAllocator failed");
+            return false;
+        }
+        return true;
+    }
+
+    bool InitCommandPool() {
+        auto& raii_dev = GaussianSplatVulkanInteropContext::GetInstance()
+                                 .GetRaiiDevice();
+        vk::CommandPoolCreateInfo ci{{}, queue_family_};
+        try {
+            cmd_pool_ = raii_dev.createCommandPool(ci);
+        } catch (const vk::SystemError& e) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vkCreateCommandPool failed: {}",
+                    e.what());
+            return false;
+        }
+        vk::CommandBufferAllocateInfo ai{
+                *cmd_pool_,
+                vk::CommandBufferLevel::ePrimary,
+                1,
+        };
+        try {
+            auto cmds = raii_dev.allocateCommandBuffers(ai);
+            cmd_ = std::move(cmds.front());
+        } catch (const vk::SystemError& e) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vkAllocateCommandBuffers failed: {}",
+                    e.what());
+            return false;
+        }
+        return true;
+    }
+
+    bool InitFence() {
+        try {
+            fence_ = GaussianSplatVulkanInteropContext::GetInstance()
+                             .GetRaiiDevice()
+                             .createFence({});
+        } catch (const vk::SystemError& e) {
+            utility::LogWarning("GaussianSplatVulkan: vkCreateFence failed: {}",
+                                e.what());
+            return false;
+        }
+        return true;
+    }
+
+    bool InitSampler() {
+        vk::SamplerCreateInfo si{
+                {},
+                vk::Filter::eNearest,
+                vk::Filter::eNearest,
+                vk::SamplerMipmapMode::eNearest,
+                vk::SamplerAddressMode::eClampToEdge,
+                vk::SamplerAddressMode::eClampToEdge,
+                vk::SamplerAddressMode::eClampToEdge,
+        };
+        try {
+            nearest_sampler_ = GaussianSplatVulkanInteropContext::GetInstance()
+                                       .GetRaiiDevice()
+                                       .createSampler(si);
+        } catch (const vk::SystemError& e) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vkCreateSampler failed: {}",
+                    e.what());
+            return false;
+        }
+        return true;
+    }
+
+    // --- Shader loading ---------------------------------------------------
+
+    bool LoadShader(ComputeProgramId id, const std::string& shader_root) {
+        const int i = static_cast<int>(id);
+        const std::string name = kGsShaderNames[i];
+        const std::string spv_path = shader_root + name + ".spv";
+        std::vector<char> bytes;
+        std::string err;
+        if (!utility::filesystem::FReadToBuffer(spv_path, bytes, &err)) {
+            utility::LogDebug("GaussianSplatVulkan: SPIR-V not found: {}",
+                              spv_path);
+            return false;
+        }
+
+        // RAII device: all vk::raii::Xxx handles auto-destroy on exception.
+        auto& raii_dev = GaussianSplatVulkanInteropContext::GetInstance()
+                                 .GetRaiiDevice();
+        vk::ShaderModuleCreateInfo smi{
+                {},
+                bytes.size(),
+                reinterpret_cast<const std::uint32_t*>(bytes.data()),
+        };
+        vk::raii::ShaderModule shader_module{nullptr};
+        try {
+            shader_module = raii_dev.createShaderModule(smi);
+        } catch (const vk::SystemError& e) {
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vkCreateShaderModule failed for {}: "
+                    "{}",
+                    name, e.what());
+            return false;
+        }
+
+        // Build descriptor set layout for this pipeline
+        const auto& bt = kShaderBindings[i];
+        std::vector<vk::DescriptorSetLayoutBinding> layout_bindings(bt.count);
+        std::uint64_t binding_mask = 0;
+        for (std::uint32_t j = 0; j < bt.count; ++j) {
+            auto& lb = layout_bindings[j];
+            lb.binding = bt.descs[j].binding;
+            lb.descriptorType =
+                    static_cast<vk::DescriptorType>(bt.descs[j].type);
+            lb.descriptorCount = 1;
+            lb.stageFlags = vk::ShaderStageFlagBits::eCompute;
+            if (lb.binding < 64) binding_mask |= (uint64_t(1) << lb.binding);
+        }
+
+        vk::DescriptorSetLayoutCreateInfo dslci{};
+        // Enable push descriptors for this layout.
+        dslci.flags = static_cast<vk::DescriptorSetLayoutCreateFlags>(
+                VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
+        dslci.bindingCount = bt.count;
+        dslci.pBindings = layout_bindings.data();
+        vk::raii::DescriptorSetLayout dset_layout{nullptr};
+        try {
+            dset_layout = raii_dev.createDescriptorSetLayout(dslci);
+        } catch (const vk::SystemError& e) {
+            // shader_module auto-destroyed by RAII
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vkCreateDescriptorSetLayout failed "
+                    "for {}: {}",
+                    name, e.what());
+            return false;
+        }
+
+        const vk::DescriptorSetLayout dsl_handle = *dset_layout;
+        vk::PipelineLayoutCreateInfo plci{{}, 1, &dsl_handle};
+        vk::raii::PipelineLayout pipeline_layout{nullptr};
+        try {
+            pipeline_layout = raii_dev.createPipelineLayout(plci);
+        } catch (const vk::SystemError& e) {
+            // dset_layout, shader_module auto-destroyed by RAII
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vkCreatePipelineLayout failed "
+                    "for {}: {}",
+                    name, e.what());
+            return false;
+        }
+
+        vk::ComputePipelineCreateInfo pci{
+                {},
+                vk::PipelineShaderStageCreateInfo{
+                        {},
+                        vk::ShaderStageFlagBits::eCompute,
+                        *shader_module,
+                        "main",
+                },
+                *pipeline_layout,
+        };
+        vk::raii::Pipeline pipeline{nullptr};
+        try {
+            pipeline = raii_dev.createComputePipeline(nullptr, pci);
+        } catch (const vk::SystemError& e) {
+            // pipeline_layout, dset_layout, shader_module auto-destroyed by
+            // RAII
+            utility::LogWarning(
+                    "GaussianSplatVulkan: vkCreateComputePipelines failed "
+                    "for {}: {}",
+                    name, e.what());
+            return false;
+        }
+        // shader_module auto-destroyed here (pipeline compiled; module no
+        // longer needed)
+
+        auto& p = pipelines_[i];
+        p.dset_layout = std::move(dset_layout);
+        p.layout = std::move(pipeline_layout);
+        p.pipeline = std::move(pipeline);
+        p.binding_mask = binding_mask;
+        p.valid = true;
+        utility::LogDebug("GaussianSplatVulkan: loaded {}", name);
+        return true;
+    }
+
+    // --- Command buffer lifecycle -----------------------------------------
+
+    void BeginCmdBuf() {
+        if (cmd_active_) return;
+        // If the geometry pass submitted a fence-only (fire-and-forget), drain
+        // it now before resetting the command pool.  Also guards the case where
+        // BeginCmdBuf is called again before a previous SubmitAndWait has had
+        // a chance to drain (e.g. geometry pass on frame N+1 before composite
+        // on frame N was submitted due to an early return).
+        WaitForPendingSubmit();
+        vk::Device(device_).resetCommandPool(*cmd_pool_, {});
+        cmd_.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
+        cmd_active_ = true;
+        active_id_ = -1;
+        pending_.clear();
+    }
+
+    // Submit the current command buffer and signal the fence, but do NOT wait.
+    // Used by EndGeometryPass() so geometry overlaps with Filament rendering.
+    // The fence is checked (and waited if necessary) in WaitForPendingSubmit(),
+    // which BeginCmdBuf() and BeginCompositePass() call before starting work.
+    void SubmitOnly() {
+        if (!cmd_active_) return;
+        cmd_.end();
+        cmd_active_ = false;
+        vk::Device(device_).resetFences({*fence_});
+        vk::CommandBufferSubmitInfo cmd_info{*cmd_, 0};
+        vk::SubmitInfo2 si{{}, {}, cmd_info, {}};
+        vk::Queue(compute_queue_).submit2(si, *fence_);
+        fence_submitted_ = true;
+        active_id_ = -1;
+        pending_.clear();
+    }
+
+    // Wait for the most recently submitted fence if one is outstanding.
+    // No-op when no submission is pending (fence_submitted_ == false).
+    void WaitForPendingSubmit() {
+        if (!fence_submitted_) return;
+        (void)vk::Device(device_).waitForFences({*fence_}, true, UINT64_MAX);
+        vk::Device(device_).resetFences({*fence_});
+        fence_submitted_ = false;
+    }
+
+    // Submit and immediately wait (used by EndCompositePass and FinishGpuWork).
+    void SubmitAndWait() {
+        SubmitOnly();
+        WaitForPendingSubmit();
+    }
+
+    // --- Descriptor helpers -----------------------------------------------
+
+    void FlushPendingBindings() {
+        if (active_id_ < 0 || pending_.empty()) return;
+        auto& p = pipelines_[active_id_];
+        // Build push descriptor writes, filtering to bindings in the layout.
+        std::vector<VkWriteDescriptorSet> writes;
+        writes.reserve(pending_.size());
+        for (auto& pw : pending_) {
+            if (pw.binding < 64 &&
+                !(p.binding_mask & (uint64_t(1) << pw.binding)))
+                continue;  // not in this pipeline's layout
+            VkWriteDescriptorSet w{};
+            w.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+            w.dstBinding = pw.binding;
+            w.descriptorCount = 1;
+            w.descriptorType = pw.type;
+            switch (pw.type) {
+                case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+                case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+                    w.pBufferInfo = &pw.buf;
+                    break;
+                case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+                case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+                    w.pImageInfo = &pw.img;
+                    break;
+                default:
+                    break;
+            }
+            writes.push_back(w);
+        }
+        if (!writes.empty()) {
+            // vkCmdPushDescriptorSetKHR is a KHR extension function; call it
+            // through the default dispatcher which was loaded with the device.
+            VULKAN_HPP_DEFAULT_DISPATCHER.vkCmdPushDescriptorSetKHR(
+                    static_cast<VkCommandBuffer>(*cmd_),
+                    VK_PIPELINE_BIND_POINT_COMPUTE,
+                    static_cast<VkPipelineLayout>(*p.layout), 0,
+                    static_cast<std::uint32_t>(writes.size()), writes.data());
+        }
+        pending_.clear();
+    }
+
+    // --- Image / view helpers ---------------------------------------------
+
+    /// Resolve a texture handle to a VkImageView: shared images are looked
+    /// up by GL name (stored in gl_to_handle_); internal textures use their
+    /// direct handle. Also ensures the image layout via a barrier.
+    VkImageView ResolveImageView(std::uintptr_t handle,
+                                 VkImageLayout needed_layout) {
+        // First check if this handle directly maps to a known texture.
+        auto it = textures_.find(handle);
+        if (it == textures_.end()) {
+            // Try interpreting the handle as a GL texture name.
+            auto git = gl_to_handle_.find(static_cast<std::uint32_t>(handle));
+            if (git == gl_to_handle_.end()) return VK_NULL_HANDLE;
+            it = textures_.find(git->second);
+            if (it == textures_.end()) return VK_NULL_HANDLE;
+        }
+        auto& e = it->second;
+        if (e.current_layout != needed_layout) {
+            TransitionImageLayout(e.image, e.format, e.current_layout,
+                                  needed_layout);
+            e.current_layout = needed_layout;
+        }
+        return static_cast<VkImageView>(*e.view);
+    }
+
+    // Layout transition for internally-owned (non-shared) VMA images only.
+    // Uses VK_QUEUE_FAMILY_IGNORED because these images are never accessed by
+    // an external API; queue-family ownership is always within this compute
+    // queue.  Shared GL-interop images must use EmitSharedInteropAcquire/
+    // ReleaseBarriers instead, which use VK_QUEUE_FAMILY_EXTERNAL.
+    void TransitionImageLayout(VkImage image,
+                               VkFormat format,
+                               VkImageLayout old_layout,
+                               VkImageLayout new_layout) {
+        const bool is_depth = (format == VK_FORMAT_D32_SFLOAT);
+        const auto src_stage =
+                (old_layout == VK_IMAGE_LAYOUT_UNDEFINED)
+                        ? vk::PipelineStageFlagBits2::eNone
+                : (old_layout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)
+                        ? vk::PipelineStageFlagBits2::eTransfer
+                        : vk::PipelineStageFlagBits2::eComputeShader;
+        const auto src_access =
+                (old_layout == VK_IMAGE_LAYOUT_UNDEFINED) ? vk::AccessFlags2{}
+                : (old_layout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)
+                        ? vk::AccessFlagBits2::eTransferRead
+                // SHADER_READ_ONLY_OPTIMAL is a read-only layout;
+                // using eShaderWrite here would be incorrect and
+                // triggers BestPractices-ImageBarrierAccessLayout.
+                : (old_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
+                        ? vk::AccessFlagBits2::eShaderRead
+                        : (vk::AccessFlagBits2::eShaderWrite |
+                           vk::AccessFlagBits2::eShaderRead);
+        const auto dst_stage =
+                (new_layout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)
+                        ? vk::PipelineStageFlagBits2::eTransfer
+                        : vk::PipelineStageFlagBits2::eComputeShader;
+        const vk::AccessFlags2 dst_access =
+                (new_layout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)
+                        ? vk::AccessFlagBits2::eTransferRead
+                : (new_layout == VK_IMAGE_LAYOUT_GENERAL)
+                        ? (vk::AccessFlagBits2::eShaderWrite |
+                           vk::AccessFlagBits2::eShaderRead)
+                        : vk::AccessFlagBits2::eShaderRead;
+        vk::ImageMemoryBarrier2 b{
+                src_stage,
+                src_access,
+                dst_stage,
+                dst_access,
+                static_cast<vk::ImageLayout>(old_layout),
+                static_cast<vk::ImageLayout>(new_layout),
+                VK_QUEUE_FAMILY_IGNORED,
+                VK_QUEUE_FAMILY_IGNORED,
+                vk::Image(image),
+                vk::ImageSubresourceRange{
+                        is_depth ? vk::ImageAspectFlagBits::eDepth
+                                 : vk::ImageAspectFlagBits::eColor,
+                        0, 1, 0, 1},
+        };
+        cmd_.pipelineBarrier2(vk::DependencyInfo{{}, {}, {}, b});
+    }
+
+    vk::raii::ImageView CreateImageView(VkImage image,
+                                        VkFormat format,
+                                        VkImageAspectFlags aspect) {
+        vk::ImageViewCreateInfo vci{
+                {},
+                vk::Image(image),
+                vk::ImageViewType::e2D,
+                static_cast<vk::Format>(format),
+                {},
+                vk::ImageSubresourceRange{
+                        static_cast<vk::ImageAspectFlags>(aspect), 0, 1, 0, 1},
+        };
+        try {
+            return GaussianSplatVulkanInteropContext::GetInstance()
+                    .GetRaiiDevice()
+                    .createImageView(vci);
+        } catch (const vk::SystemError&) {
+            return vk::raii::ImageView{nullptr};
+        }
+    }
+
+    // --- Buffer allocation ------------------------------------------------
+
+    std::uintptr_t AllocBuf(std::size_t size, bool priv, const char* /*lbl*/) {
+        if (size == 0) return 0;
+        VkBufferCreateInfo bci{};
+        bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+        bci.size = size;
+        bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
+                    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
+                    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT |
+                    VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+                    VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+        bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+        VmaAllocationCreateInfo aci{};
+        if (priv) {
+            aci.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+        } else {
+            aci.usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
+            aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+        }
+
+        VmaAllocation alloc = VK_NULL_HANDLE;
+        VkBuffer buf = VK_NULL_HANDLE;
+        VmaAllocationInfo info{};
+        if (vmaCreateBuffer(vma_, &bci, &aci, &buf, &alloc, &info) !=
+            VK_SUCCESS)
+            return 0;
+
+        uintptr_t handle = next_handle_++;
+        BufEntry& e = buffers_[handle];
+        e.alloc = alloc;
+        e.buffer = buf;
+        e.size = size;
+        e.mapped = priv ? nullptr : info.pMappedData;
+        e.is_private = priv;
+        return handle;
+    }
+
+    // --- Texture/image allocation -----------------------------------------
+
+    std::uintptr_t AllocTex(std::uint32_t w,
+                            std::uint32_t h,
+                            VkFormat format,
+                            VkImageUsageFlags usage,
+                            VkImageAspectFlags aspect) {
+        VkImageCreateInfo ici{};
+        ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+        ici.imageType = VK_IMAGE_TYPE_2D;
+        ici.format = format;
+        ici.extent = {w, h, 1};
+        ici.mipLevels = 1;
+        ici.arrayLayers = 1;
+        ici.samples = VK_SAMPLE_COUNT_1_BIT;
+        ici.tiling = VK_IMAGE_TILING_OPTIMAL;
+        ici.usage = usage;
+        ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+        ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+        VmaAllocationCreateInfo aci{};
+        aci.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+        VmaAllocation alloc = VK_NULL_HANDLE;
+        VkImage image = VK_NULL_HANDLE;
+        if (vmaCreateImage(vma_, &ici, &aci, &image, &alloc, nullptr) !=
+            VK_SUCCESS)
+            return 0;
+        vk::raii::ImageView view = CreateImageView(image, format, aspect);
+        if (static_cast<VkImageView>(*view) == VK_NULL_HANDLE) {
+            vmaDestroyImage(vma_, image, alloc);
+            return 0;
+        }
+        uintptr_t handle = next_handle_++;
+        TexEntry& e = textures_[handle];
+        e.alloc = alloc;
+        e.image = image;
+        e.view = std::move(view);
+        e.format = format;
+        e.width = w;
+        e.height = h;
+        e.current_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+        e.is_shared = false;
+        return handle;
+    }
+
+    // --- Download helpers -------------------------------------------------
+
+    template <typename T>
+    bool DownloadTexBytes(std::uintptr_t tex,
+                          std::uint32_t w,
+                          std::uint32_t h,
+                          std::size_t bytes_per_elem,
+                          std::vector<T>& out) {
+        auto it = textures_.find(tex);
+        if (it == textures_.end() || w == 0 || h == 0) return false;
+        const std::size_t row_size =
+                static_cast<std::size_t>(w) * bytes_per_elem;
+        const std::size_t total = row_size * h;
+        out.resize(static_cast<std::size_t>(w) * h);
+
+        // Create a staging readback buffer.
+        VkBufferCreateInfo bci{};
+        bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+        bci.size = total;
+        bci.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+        VmaAllocationCreateInfo aci{};
+        aci.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
+        aci.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+        VmaAllocation alloc = VK_NULL_HANDLE;
+        VkBuffer staging = VK_NULL_HANDLE;
+        VmaAllocationInfo info{};
+        if (vmaCreateBuffer(vma_, &bci, &aci, &staging, &alloc, &info) !=
+            VK_SUCCESS)
+            return false;
+
+        // Record copy: transition image to TRANSFER_SRC, copy, transition
+        // back.
+        BeginCmdBuf();
+        auto& e = it->second;
+        TransitionImageLayout(e.image, e.format, e.current_layout,
+                              VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+        vk::BufferImageCopy region{
+                0,         0,
+                0,         {vk::ImageAspectFlagBits::eColor, 0, 0, 1},
+                {0, 0, 0}, {w, h, 1},
+        };
+        cmd_.copyImageToBuffer(vk::Image(e.image),
+                               vk::ImageLayout::eTransferSrcOptimal,
+                               vk::Buffer(staging), region);
+        // Transition back to previous layout (or GENERAL).
+        TransitionImageLayout(e.image, e.format,
+                              VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                              e.current_layout == VK_IMAGE_LAYOUT_UNDEFINED
+                                      ? VK_IMAGE_LAYOUT_GENERAL
+                                      : e.current_layout);
+        SubmitAndWait();
+
+        std::memcpy(out.data(), info.pMappedData, total);
+        vmaDestroyBuffer(vma_, staging, alloc);
+
+        // Flip bottom-up → top-down (matches GL / Filament readPixels).
+        for (std::uint32_t row = 0; row < h / 2; ++row) {
+            std::swap_ranges(out.begin() + row * w, out.begin() + row * w + w,
+                             out.begin() + (h - 1 - row) * w);
+        }
+        return true;
+    }
+
+    // --- Shutdown ---------------------------------------------------------
+
+    void Shutdown() {
+        if (device_ == VK_NULL_HANDLE) return;
+        vk::Device(device_).waitIdle();
+
+        // Destroy image views (RAII) before their VMA images.
+        for (auto& [h, e] : textures_) {
+            e.view = vk::raii::ImageView{nullptr};  // vkDestroyImageView
+            if (!e.is_shared && e.alloc != VK_NULL_HANDLE)
+                vmaDestroyImage(vma_, e.image, e.alloc);
+        }
+        textures_.clear();
+
+        // Destroy VMA buffers.
+        for (auto& [h, e] : buffers_) {
+            vmaDestroyBuffer(vma_, e.buffer, e.alloc);
+        }
+        buffers_.clear();
+
+        // Reset pipeline RAII handles: destroys pipelines, layouts, dset
+        // layouts.
+        for (auto& p : pipelines_) {
+            p.pipeline = vk::raii::Pipeline{nullptr};
+            p.layout = vk::raii::PipelineLayout{nullptr};
+            p.dset_layout = vk::raii::DescriptorSetLayout{nullptr};
+            p.valid = false;
+        }
+
+        // Reset remaining RAII handles in reverse init order.
+        nearest_sampler_ = vk::raii::Sampler{nullptr};
+        fence_ = vk::raii::Fence{nullptr};
+        cmd_ = vk::raii::CommandBuffer{nullptr};
+        cmd_pool_ = vk::raii::CommandPool{nullptr};
+        if (vma_ != VK_NULL_HANDLE) {
+            vmaDestroyAllocator(vma_);
+            vma_ = VK_NULL_HANDLE;
+        }
+        device_ = VK_NULL_HANDLE;
+    }
+};
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+void RegisterSharedImageInVulkanContext(GaussianSplatGpuContext& ctx,
+                                        std::uint32_t gl_name,
+                                        std::uintptr_t vk_image_opaque,
+                                        std::uint32_t vk_format_opaque,
+                                        std::uint32_t width,
+                                        std::uint32_t height) {
+    auto* vk_ctx = dynamic_cast<GaussianSplatGpuContextVulkan*>(&ctx);
+    if (!vk_ctx) return;
+    vk_ctx->RegisterSharedImage(
+            gl_name, reinterpret_cast<VkImage>(vk_image_opaque),
+            static_cast<VkFormat>(vk_format_opaque), width, height);
+}
+
+void UnregisterSharedImageFromVulkanContext(GaussianSplatGpuContext& ctx,
+                                            std::uint32_t gl_name) {
+    auto* vk_ctx = dynamic_cast<GaussianSplatGpuContextVulkan*>(&ctx);
+    if (!vk_ctx) return;
+    vk_ctx->UnregisterSharedImage(gl_name);
+}
+
+std::unique_ptr<GaussianSplatGpuContext> CreateComputeGpuContextVulkan() {
+    auto& interop = GaussianSplatVulkanInteropContext::GetInstance();
+    if (!interop.IsValid()) {
+        utility::LogWarning(
+                "GaussianSplatVulkan: interop context not initialized; "
+                "Vulkan compute context not created");
+        return nullptr;
+    }
+    return std::make_unique<GaussianSplatGpuContextVulkan>();
+}
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
+
+#endif  // !defined(__APPLE__)
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUVulkan.h b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUVulkan.h
new file mode 100644
index 00000000000..96fe8105100
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/ComputeGPUVulkan.h
@@ -0,0 +1,66 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+//
+// Vulkan compute backend for the Gaussian splatting pipeline.
+// Compiled on non-Apple platforms.
+//
+// Key design:
+//   - Implements GaussianSplatGpuContext backed by Vulkan compute pipelines
+//     loaded from SPIR-V assets at resources/gaussian_splat/.
+//   - Uses VK_KHR_push_descriptor for efficient per-dispatch binding (no
+//     descriptor pool allocation per frame).
+//   - Uses VMA for general buffer/image allocation.  Shared cross-API images
+//     (color, depth) are registered via RegisterSharedImageInVulkanContext()
+//     rather than allocated here; VulkanInteropContext owns those.
+//   - Synchronisation: each EndXxxPass() submits and waits (fence-based) so
+//     the rest of the pipeline sees a completed GPU result.
+
+#pragma once
+
+#if !defined(__APPLE__)
+
+#include <cstdint>
+#include <memory>
+
+#include "open3d/visualization/rendering/gaussian_splat/ComputeGPU.h"
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+/// Register a GL-Vulkan shared image with a Vulkan compute context so that
+/// subsequent BindImage() / BindSamplerTexture() calls for that GL texture
+/// name resolve to the backing VkImage.
+///
+/// @param ctx               Created by CreateComputeGpuContextVulkan().
+/// @param gl_name           GL texture name from SharedImageDesc.gl_texture.
+/// @param vk_image_opaque   SharedImageDesc.vk_image cast to uintptr_t.
+/// @param vk_format_opaque  VkFormat value cast to uint32_t.
+/// @param width, height     Image dimensions in pixels.
+void RegisterSharedImageInVulkanContext(GaussianSplatGpuContext& ctx,
+                                        std::uint32_t gl_name,
+                                        std::uintptr_t vk_image_opaque,
+                                        std::uint32_t vk_format_opaque,
+                                        std::uint32_t width,
+                                        std::uint32_t height);
+
+/// Unregister a previously registered shared image (called on resize / teardown
+/// before VulkanInteropContext::DestroySharedImage).
+void UnregisterSharedImageFromVulkanContext(GaussianSplatGpuContext& ctx,
+                                            std::uint32_t gl_name);
+
+/// Factory: create a Vulkan-backed GaussianSplatGpuContext.
+/// Uses device / queue from GaussianSplatVulkanInteropContext::GetInstance().
+/// Returns nullptr if the interop context is not initialized.
+[[nodiscard]] std::unique_ptr<GaussianSplatGpuContext>
+CreateComputeGpuContextVulkan();
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
+
+#endif  // !defined(__APPLE__)
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatOpenGLContext.cpp b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatOpenGLContext.cpp
new file mode 100644
index 00000000000..f931b07c392
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatOpenGLContext.cpp
@@ -0,0 +1,227 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+//
+// OpenGL context management for Gaussian splatting compute.
+//
+// A hidden GLFW window owns a GL 4.6 core-profile context. Its native handle
+// (GLXContext on Linux/X11/XWayland, HGLRC on Windows) is passed to Filament's
+// Engine::create() as sharedGLContext so both contexts share the same GL object
+// namespace for zero-copy texture import.
+//
+// Linux intentionally uses GLFW's X11 platform only; EGL is not used because
+// Filament's Linux OpenGL backend is PlatformGLX. Offscreen rendering on Linux
+// therefore requires an X11 or XWayland server.
+
+#include "open3d/visualization/rendering/gaussian_splat/GaussianSplatOpenGLContext.h"
+
+#if !defined(__APPLE__)
+
+#include <cstdlib>
+#include <cstring>
+
+#include "open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.h"
+
+// GLFW for cross-platform hidden window and context creation.
+#define GLFW_INCLUDE_NONE
+#include <GLFW/glfw3.h>
+
+// GLEW must be included before any GL header pulled in by glfw3native.h.
+#include <GL/glew.h>
+
+#if defined(_WIN32)
+#define GLFW_EXPOSE_NATIVE_WIN32
+#define GLFW_EXPOSE_NATIVE_WGL
+#else
+#define GLFW_EXPOSE_NATIVE_X11
+#define GLFW_EXPOSE_NATIVE_GLX
+#endif
+#include <GLFW/glfw3native.h>
+
+#include "open3d/utility/Logging.h"
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+namespace {
+
+const char* GetSessionType() {
+#if defined(_WIN32)
+    return "windows";
+#else
+    const char* session = std::getenv("XDG_SESSION_TYPE");
+    return session ? session : "unknown";
+#endif
+}
+
+const char* GetNativeBackendName() {
+#if defined(_WIN32)
+    return "WGL";
+#else
+    return "GLX";
+#endif
+}
+
+}  // namespace
+
+GaussianSplatOpenGLContext& GaussianSplatOpenGLContext::GetInstance() {
+    static GaussianSplatOpenGLContext instance;
+    return instance;
+}
+
+GaussianSplatOpenGLContext::~GaussianSplatOpenGLContext() { Shutdown(); }
+
+bool GaussianSplatOpenGLContext::InitializeStandalone() {
+    if (initialized_) {
+        return true;
+    }
+
+#if !defined(_WIN32)
+    if (std::strcmp(GetSessionType(), "wayland") == 0) {
+        utility::LogInfo(
+                "GaussianSplatOpenGLContext: Wayland session detected; "
+                "using X11/GLX via XWayland for Filament compatibility.");
+    }
+#endif
+
+    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
+    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_FALSE);
+
+    GLFWwindow* window =
+            glfwCreateWindow(1, 1, "O3D_GS_Helper", nullptr, nullptr);
+    glfwDefaultWindowHints();
+    if (!window) {
+        utility::LogWarning(
+                "GaussianSplatOpenGLContext: glfwCreateWindow failed. "
+                "Linux offscreen rendering now requires an X11/XWayland "
+                "server.");
+        return false;
+    }
+
+    glfwMakeContextCurrent(window);
+    glewExperimental = GL_TRUE;
+    const GLenum glew_err = glewInit();
+    while (glGetError() != GL_NO_ERROR) {
+    }
+    if (glew_err != GLEW_OK) {
+        utility::LogWarning(
+                "GaussianSplatOpenGLContext: glewInit warning: {}",
+                reinterpret_cast<const char*>(glewGetErrorString(glew_err)));
+    }
+
+    glfw_window_ = window;
+    initialized_ = true;
+
+    // After glewInit(), probe GL interop extensions for the Vulkan interop
+    // context (EXT_memory_object_fd, etc.).
+    // This must happen while the GL context is current.
+    auto& vk_ctx = GaussianSplatVulkanInteropContext::GetInstance();
+    if (vk_ctx.IsValid() && !vk_ctx.AreGLExtensionsReady()) {
+        vk_ctx.ProbeGLExtensions();
+    }
+
+    const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
+    const char* renderer =
+            reinterpret_cast<const char*>(glGetString(GL_RENDERER));
+    const char* version =
+            reinterpret_cast<const char*>(glGetString(GL_VERSION));
+    utility::LogDebug(
+            "GaussianSplatOpenGLContext: Created standalone {} context "
+            "for session={} native={:p}",
+            GetNativeBackendName(), GetSessionType(), GetNativeContext());
+    utility::LogDebug(
+            "GaussianSplatOpenGLContext: GL vendor={} renderer={} "
+            "version={}",
+            vendor ? vendor : "?", renderer ? renderer : "?",
+            version ? version : "?");
+
+    glfwMakeContextCurrent(nullptr);
+    return true;
+}
+
+bool GaussianSplatOpenGLContext::Initialize() {
+    if (initialized_) {
+        return true;
+    }
+
+    utility::LogWarning(
+            "GaussianSplatOpenGLContext: late initialization is not "
+            "supported. InitializeStandalone() must run before Filament "
+            "Engine::create() so zero-copy sharedGLContext setup succeeds.");
+    return false;
+}
+
+void* GaussianSplatOpenGLContext::GetNativeContext() const {
+    if (!glfw_window_) {
+        return nullptr;
+    }
+
+    GLFWwindow* window = static_cast<GLFWwindow*>(glfw_window_);
+#if defined(_WIN32)
+    return reinterpret_cast<void*>(glfwGetWGLContext(window));
+#else
+    return reinterpret_cast<void*>(glfwGetGLXContext(window));
+#endif
+}
+
+void GaussianSplatOpenGLContext::Shutdown() {
+    if (!initialized_) {
+        return;
+    }
+
+    glfwMakeContextCurrent(nullptr);
+    glfwDestroyWindow(static_cast<GLFWwindow*>(glfw_window_));
+    glfw_window_ = nullptr;
+    initialized_ = false;
+    gl_logged_ = false;
+    utility::LogDebug("GaussianSplatOpenGLContext: Shut down.");
+}
+
+bool GaussianSplatOpenGLContext::IsValid() const { return initialized_; }
+
+bool GaussianSplatOpenGLContext::MakeCurrent() {
+    if (!initialized_) {
+        return false;
+    }
+
+    GLFWwindow* window = static_cast<GLFWwindow*>(glfw_window_);
+    glfwMakeContextCurrent(window);
+    const bool ok = (glfwGetCurrentContext() == window);
+    if (!ok) {
+        utility::LogWarning(
+                "GaussianSplatOpenGLContext: glfwMakeContextCurrent "
+                "failed.");
+        return false;
+    }
+
+    if (!gl_logged_) {
+        gl_logged_ = true;
+        const char* version =
+                reinterpret_cast<const char*>(glGetString(GL_VERSION));
+        const char* renderer =
+                reinterpret_cast<const char*>(glGetString(GL_RENDERER));
+        utility::LogDebug("GaussianSplatOpenGLContext: {} active - GL {} on {}",
+                          GetNativeBackendName(), version ? version : "?",
+                          renderer ? renderer : "?");
+    }
+
+    return true;
+}
+
+void GaussianSplatOpenGLContext::ReleaseCurrent() {
+    glfwMakeContextCurrent(nullptr);
+}
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
+
+#endif  // !defined(__APPLE__)
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatOpenGLContext.h b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatOpenGLContext.h
new file mode 100644
index 00000000000..b324e76781f
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatOpenGLContext.h
@@ -0,0 +1,85 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+
+// GL context management for OpenGL compute-based Gaussian splatting.
+// Uses a hidden GLFW window with a GL 4.6 core-profile context and exposes
+// the native handle (GLXContext on Linux/X11/XWayland, HGLRC on Windows) so
+// Filament can create its own context sharing the same GL object namespace.
+//
+// Offscreen rendering on Linux now requires an X11 or XWayland server. EGL is
+// intentionally not used because Filament's Linux OpenGL path is GLX-only.
+
+#pragma once
+
+#if !defined(__APPLE__)
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+/// Manages a shared OpenGL 4.6 context for Gaussian splatting compute.
+/// GLFW handles platform-specific context creation (GLX on Linux/X11/XWayland,
+/// WGL on Windows).
+///
+/// Lifecycle:
+///   1. Call InitializeStandalone() before Filament Engine::create().
+///   2. Pass GetNativeContext() to Engine::create() as sharedGLContext.
+///   3. For compute work: MakeCurrent() → dispatch → ReleaseCurrent().
+///   4. Call Shutdown() when done.
+class GaussianSplatOpenGLContext {
+public:
+    static GaussianSplatOpenGLContext& GetInstance();
+
+    /// Creates a hidden GLFW window carrying a GL 4.6 core-profile context.
+    /// Must be called before Filament Engine::create() so the returned native
+    /// context can be passed as sharedGLContext for zero-copy sharing.
+    bool InitializeStandalone();
+
+    /// Safety wrapper used from render paths. Late initialization cannot
+    /// establish zero-copy sharing with Filament, so this only succeeds when
+    /// InitializeStandalone() already ran.
+    bool Initialize();
+
+    /// Returns the native context handle suitable for Filament's
+    /// sharedGLContext parameter:
+    ///   Linux   -> GLXContext
+    ///   Windows -> HGLRC
+    void* GetNativeContext() const;
+
+    /// Destroys the context and associated resources.
+    void Shutdown();
+
+    /// Returns true if the context is initialized and valid.
+    bool IsValid() const;
+
+    /// Makes this context current on the calling thread.
+    bool MakeCurrent();
+
+    /// Releases the context (no context current on this thread).
+    void ReleaseCurrent();
+
+private:
+    GaussianSplatOpenGLContext() = default;
+    ~GaussianSplatOpenGLContext();
+
+    GaussianSplatOpenGLContext(const GaussianSplatOpenGLContext&) = delete;
+    GaussianSplatOpenGLContext& operator=(const GaussianSplatOpenGLContext&) =
+            delete;
+
+private:
+    // Stored as void* (== GLFWwindow*) to avoid a GLFW header dependency.
+    void* glfw_window_ = nullptr;
+
+    bool initialized_ = false;
+    bool gl_logged_ = false;
+};
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
+
+#endif  // !defined(__APPLE__)
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.cpp b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.cpp
new file mode 100644
index 00000000000..2a327943d6e
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.cpp
@@ -0,0 +1,806 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+//
+// Vulkan-OpenGL interop context implementation (Linux and Windows).
+//
+// Sequence of calls for one shared image (colour or depth):
+//   1. AllocateExportableImage() → VkImage + VkDeviceMemory + FD
+//   2. ImportFDIntoGL()          → gl_memory_object + gl_texture
+//   3. (caller) CreateImportedTexture(gl_texture, ...) into Filament
+
+#if defined(_WIN32)
+// Ensure Vulkan Win32 platform symbols and Win32 types (HANDLE) are
+// available in this translation unit before any Vulkan headers are
+// included by the context header.
+#ifndef VK_USE_PLATFORM_WIN32_KHR
+#define VK_USE_PLATFORM_WIN32_KHR 1
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+
+#endif
+
+#include "open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.h"
+
+#if !defined(__APPLE__)
+
+// Provide storage for vulkan-hpp's global dynamic dispatch loader (exactly one
+// translation unit in the program must define this macro).
+VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+
+#include <GL/glew.h>
+
+#include <cstdlib>
+#include <cstring>
+#include <vector>
+
+#include "open3d/utility/Logging.h"
+
+// Initialize VMA in this single translation unit.
+// VK_NO_PROTOTYPES is already defined via vulkan_raii.hpp (included in the
+// context header), so VMA must use VmaVulkanFunctions rather than calling
+// Vulkan symbols directly.
+#define VMA_STATIC_VULKAN_FUNCTIONS 0
+#define VMA_DYNAMIC_VULKAN_FUNCTIONS 0
+#ifndef _MSC_VER
+// Suppress pedantic warnings inside the VMA header-only implementation.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#pragma GCC diagnostic ignored "-Wparentheses"
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+#endif
+#define VMA_IMPLEMENTATION
+#include "vk_mem_alloc.hpp"
+#ifndef _MSC_VER
+#pragma GCC diagnostic pop
+#endif
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+// ---------------------------------------------------------------------------
+// Required Vulkan device extensions for interop
+// ---------------------------------------------------------------------------
+namespace {
+
+#if defined(_WIN32)
+constexpr const char* kRequiredDeviceExtensions[] = {
+        VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME,
+        VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
+};
+#else
+constexpr const char* kRequiredDeviceExtensions[] = {
+        VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME,
+        VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
+};
+#endif
+
+bool ShouldEnableDebugUtils() {
+    const char* value = std::getenv("OPEN3D_VULKAN_DEBUG_UTILS");
+    return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
+}
+
+/// Returns true when all extensions in 'required' are present in
+/// 'available'.  Sets out_missing to the first missing extension name.
+bool CheckExtensions(const std::vector<vk::ExtensionProperties>& available,
+                     const char* const* required,
+                     std::size_t required_count,
+                     std::string& out_missing) {
+    for (std::size_t i = 0; i < required_count; ++i) {
+        bool found = false;
+        for (const auto& ext : available) {
+            if (std::strcmp(ext.extensionName, required[i]) == 0) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            out_missing = required[i];
+            return false;
+        }
+    }
+    return true;
+}
+
+/// Score a physical device for interop suitability.  Higher is better.
+///  +2  : discrete GPU
+///  +1  : integrated GPU
+///   0  : any compute-capable device
+///  -∞  : no compute queue or missing required extensions → reject
+int ScoreDevice(const vk::raii::PhysicalDevice& dev) {
+    // Check for a compute queue.
+    const auto qfams = dev.getQueueFamilyProperties();
+    bool has_compute = false;
+    for (const auto& qf : qfams) {
+        if (qf.queueFlags & vk::QueueFlagBits::eCompute) {
+            has_compute = true;
+            break;
+        }
+    }
+    if (!has_compute) return -1;
+
+    // Check device extensions.
+    const auto exts = dev.enumerateDeviceExtensionProperties();
+
+    std::string missing;
+    const bool ok =
+            CheckExtensions(exts, kRequiredDeviceExtensions,
+                            std::size(kRequiredDeviceExtensions), missing);
+    if (!ok) return -1;
+
+    // Shaders are compiled for Vulkan 1.3 (SPIR-V 1.6); reject older devices.
+    const auto props = dev.getProperties();
+    if (props.apiVersion < VK_API_VERSION_1_3) return -1;
+
+    // Score device type.
+    if (props.deviceType == vk::PhysicalDeviceType::eDiscreteGpu) return 2;
+    if (props.deviceType == vk::PhysicalDeviceType::eIntegratedGpu) return 1;
+    return 0;
+}
+
+}  // namespace
+
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+
+GaussianSplatVulkanInteropContext&
+GaussianSplatVulkanInteropContext::GetInstance() {
+    static GaussianSplatVulkanInteropContext instance;
+    return instance;
+}
+
+GaussianSplatVulkanInteropContext::~GaussianSplatVulkanInteropContext() {
+    Shutdown();
+}
+
+// ---------------------------------------------------------------------------
+// Initialize / Shutdown
+// ---------------------------------------------------------------------------
+
+bool GaussianSplatVulkanInteropContext::Initialize() {
+    if (initialized_) return true;
+
+    // Initialize the global dynamic dispatcher with vkGetInstanceProcAddr
+    // obtained from the Vulkan loader via vulkan-hpp's DynamicLoader utility.
+    // This loads instance-independent entry points (e.g. vkCreateInstance).
+    try {
+        VULKAN_HPP_DEFAULT_DISPATCHER.init(
+                vk::detail::DynamicLoader()
+                        .getProcAddress<PFN_vkGetInstanceProcAddr>(
+                                "vkGetInstanceProcAddr"));
+    } catch (const std::exception& e) {
+        last_error_ = std::string("Vulkan loader not found: ") + e.what();
+        utility::LogWarning("GaussianSplat Vulkan: {}", last_error_);
+        return false;
+    }
+
+    if (!CreateInstance()) return false;
+
+    // After instance creation, update the dispatcher with instance-level
+    // function pointers (required for physical device enumeration etc.).
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(static_cast<vk::Instance>(*instance_));
+
+    if (!SelectPhysicalDevice()) return false;
+    if (!CreateLogicalDevice()) return false;
+
+    // After device creation, update the dispatcher with device-level
+    // function pointers for push descriptors and other extensions.
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(static_cast<vk::Device>(*device_));
+
+    initialized_ = true;
+    utility::LogDebug("GaussianSplat VulkanInteropContext: initialized ({})",
+                      physical_device_.getProperties().deviceName.data());
+    return true;
+}
+
+void GaussianSplatVulkanInteropContext::Shutdown() {
+    if (!initialized_) return;
+
+    // Wait for idle before releasing sub-objects.  The raw VkDevice is
+    // extracted before the raii handle is reset so the call is valid.
+    if (*device_) {
+        try {
+            device_.waitIdle();
+        } catch (const vk::SystemError& e) {
+            utility::LogWarning(
+                    "GaussianSplat VulkanInteropContext: waitIdle during "
+                    "shutdown failed: {}",
+                    e.what());
+        }
+    }
+
+    // Resetting in reverse construction order: queue → device → physical →
+    // instance → context. vk::raii handles call vkDestroy* in their dtors.
+    compute_queue_ = vk::raii::Queue{nullptr};
+    device_ = vk::raii::Device{nullptr};
+    physical_device_ = vk::raii::PhysicalDevice{nullptr};
+    instance_ = vk::raii::Instance{nullptr};
+    // context_ is a value member; its dtor unloads the Vulkan loader.
+
+    compute_queue_family_ = UINT32_MAX;
+    initialized_ = false;
+    gl_extensions_ok_ = false;
+    utility::LogDebug("GaussianSplat VulkanInteropContext: shutdown");
+}
+
+// ---------------------------------------------------------------------------
+// ProbeGLExtensions
+// ---------------------------------------------------------------------------
+
+bool GaussianSplatVulkanInteropContext::ProbeGLExtensions() {
+    // All required GL interop extension entry points are loaded by GLEW
+    // after glewInit(). GLEW_GET_FUN returns nullptr for absent extensions.
+    struct GLExtEntry {
+        const char* name;
+        bool present;
+    } entries[] = {
+            {"GL_EXT_memory_object", GLEW_EXT_memory_object != 0},
+#if defined(_WIN32)
+            {"GL_EXT_memory_object_win32", GLEW_EXT_memory_object_win32 != 0},
+#else
+            {"GL_EXT_memory_object_fd", GLEW_EXT_memory_object_fd != 0},
+#endif
+    };
+
+    for (const auto& e : entries) {
+        if (!e.present) {
+            last_error_ = std::string("Missing GL extension: ") + e.name;
+            utility::LogWarning("GaussianSplat Vulkan interop: {}",
+                                last_error_);
+            return false;
+        }
+    }
+    gl_extensions_ok_ = true;
+    utility::LogDebug(
+            "GaussianSplat Vulkan interop: all GL extensions present");
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Instance creation
+// ---------------------------------------------------------------------------
+
+bool GaussianSplatVulkanInteropContext::CreateInstance() {
+    // Query instance extensions so we can enable VK_EXT_debug_utils only when
+    // explicitly requested for validation/profiling runs.
+    const auto available_exts = context_.enumerateInstanceExtensionProperties();
+
+    std::vector<const char*> extensions;
+    if (ShouldEnableDebugUtils()) {
+        for (const auto& ext : available_exts) {
+            if (std::strcmp(ext.extensionName,
+                            VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) {
+                extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+                debug_utils_enabled_ = true;
+                break;
+            }
+        }
+    }
+
+    // Shaders are compiled for --target-env vulkan1.3 (SPIR-V 1.6).
+    // The instance must advertise 1.3 or vkCreateShaderModule rejects them.
+    vk::ApplicationInfo app_info{
+            "Open3D GaussianSplat",  // pApplicationName
+            1,                       // applicationVersion
+            nullptr,                 // pEngineName
+            0,                       // engineVersion
+            VK_API_VERSION_1_3,      // apiVersion
+    };
+    vk::InstanceCreateInfo ci({}, &app_info, {}, extensions);
+
+    try {
+        instance_ = context_.createInstance(ci);
+    } catch (const vk::SystemError& e) {
+        last_error_ = std::string("vkCreateInstance failed: ") + e.what();
+        utility::LogWarning("GaussianSplat Vulkan: {}", last_error_);
+        return false;
+    }
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Physical device selection
+// ---------------------------------------------------------------------------
+
+bool GaussianSplatVulkanInteropContext::SelectPhysicalDevice() {
+    auto devices = instance_.enumeratePhysicalDevices();
+    if (devices.empty()) {
+        last_error_ = "No Vulkan-capable devices found";
+        utility::LogWarning("GaussianSplat Vulkan: {}", last_error_);
+        return false;
+    }
+
+    int best_score = -1;
+    std::size_t best_idx = devices.size();
+    for (std::size_t i = 0; i < devices.size(); ++i) {
+        const int score = ScoreDevice(devices[i]);
+        if (score > best_score) {
+            best_score = score;
+            best_idx = i;
+        }
+    }
+
+    if (best_idx == devices.size()) {
+        last_error_ =
+                "No suitable Vulkan device found with required interop "
+                "extensions. Required "
+                "extensions: " VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME;
+        utility::LogWarning("GaussianSplat Vulkan: {}", last_error_);
+        return false;
+    }
+    physical_device_ = std::move(devices[best_idx]);
+
+    const auto props = physical_device_.getProperties();
+    memory_props_ = static_cast<VkPhysicalDeviceMemoryProperties>(
+            physical_device_.getMemoryProperties());
+    utility::LogDebug("GaussianSplat Vulkan: selected device '{}'",
+                      props.deviceName.data());
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Logical device and compute queue
+// ---------------------------------------------------------------------------
+
+bool GaussianSplatVulkanInteropContext::CreateLogicalDevice() {
+    const auto qfams = physical_device_.getQueueFamilyProperties();
+
+    // Prefer a queue family that supports both GRAPHICS and COMPUTE — the
+    // same hardware engine (RCS on Intel, GFX on AMD) as the OpenGL context.
+    // Dedicated compute-only queues (CCS on Intel) can behave differently for
+    // the same SPIR-V shaders and may hang on some driver/hardware combos.
+    // Fall back to a compute-only queue only when no graphics+compute family
+    // exists.
+    std::uint32_t graphics_compute_family = UINT32_MAX;
+    std::uint32_t compute_only_family = UINT32_MAX;
+    for (std::uint32_t i = 0; i < static_cast<std::uint32_t>(qfams.size());
+         ++i) {
+        const auto flags = qfams[i].queueFlags;
+        if ((flags & vk::QueueFlagBits::eCompute) &&
+            (flags & vk::QueueFlagBits::eGraphics)) {
+            if (graphics_compute_family == UINT32_MAX)
+                graphics_compute_family = i;
+        } else if ((flags & vk::QueueFlagBits::eCompute) &&
+                   compute_only_family == UINT32_MAX) {
+            compute_only_family = i;
+        }
+    }
+    compute_queue_family_ = (graphics_compute_family != UINT32_MAX)
+                                    ? graphics_compute_family
+                                    : compute_only_family;
+    if (compute_queue_family_ == UINT32_MAX) {
+        last_error_ = "No compute queue family found";
+        utility::LogWarning("GaussianSplat Vulkan: {}", last_error_);
+        return false;
+    }
+
+    const float queue_priority = 1.0f;
+    vk::DeviceQueueCreateInfo qci({}, compute_queue_family_, 1,
+                                  &queue_priority);
+
+    // Request only the Vulkan 1.3 features this backend actually uses.
+    // The command path relies on vkQueueSubmit2 / vkCmdPipelineBarrier2, so
+    // synchronization2 must be enabled. Subgroup variants are selected from
+    // properties and supported-operation bits only.
+    auto supported_features =
+            physical_device_.getFeatures2<vk::PhysicalDeviceFeatures2,
+                                          vk::PhysicalDeviceVulkan13Features>();
+    const auto& supported_vulkan13 =
+            supported_features.get<vk::PhysicalDeviceVulkan13Features>();
+    if (supported_vulkan13.synchronization2 != VK_TRUE) {
+        last_error_ =
+                "Selected Vulkan device does not support synchronization2";
+        utility::LogWarning("GaussianSplat Vulkan: {}", last_error_);
+        return false;
+    }
+
+    vk::StructureChain<vk::PhysicalDeviceFeatures2,
+                       vk::PhysicalDeviceVulkan13Features>
+            enabled_features;
+    enabled_features.get<vk::PhysicalDeviceVulkan13Features>()
+            .synchronization2 = VK_TRUE;
+
+    vk::DeviceCreateInfo dci({}, qci, {}, kRequiredDeviceExtensions);
+    dci.pNext = &enabled_features.get<vk::PhysicalDeviceFeatures2>();
+
+    try {
+        device_ = physical_device_.createDevice(dci);
+    } catch (const vk::SystemError& e) {
+        last_error_ = std::string("vkCreateDevice failed: ") + e.what();
+        utility::LogWarning("GaussianSplat Vulkan: {}", last_error_);
+        return false;
+    }
+    compute_queue_ = device_.getQueue(compute_queue_family_, 0);
+
+    // Query the hardware subgroup size so callers can skip _subgroup shader
+    // variants when the device subgroup size is too small (e.g. Intel Xe2=8).
+    auto props11 =
+            physical_device_
+                    .getProperties2<vk::PhysicalDeviceProperties2,
+                                    vk::PhysicalDeviceVulkan11Properties>();
+    const auto& subgroup_props =
+            props11.get<vk::PhysicalDeviceVulkan11Properties>();
+    subgroup_size_ = subgroup_props.subgroupSize;
+    subgroup_supported_stages_ =
+            static_cast<std::uint32_t>(subgroup_props.subgroupSupportedStages);
+    subgroup_supported_operations_ = static_cast<std::uint32_t>(
+            subgroup_props.subgroupSupportedOperations);
+
+    utility::LogDebug(
+            "GaussianSplat Vulkan: compute queue family {}, "
+            "subgroupSize={}, subgroupStages=0x{:x}, "
+            "subgroupOps=0x{:x}, synchronization2={}",
+            compute_queue_family_, subgroup_size_, subgroup_supported_stages_,
+            subgroup_supported_operations_,
+            supported_vulkan13.synchronization2 == VK_TRUE);
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// Memory type helper
+// ---------------------------------------------------------------------------
+
+std::uint32_t GaussianSplatVulkanInteropContext::FindMemoryType(
+        std::uint32_t type_filter, VkMemoryPropertyFlags props) const {
+    for (std::uint32_t i = 0; i < memory_props_.memoryTypeCount; ++i) {
+        if ((type_filter & (1u << i)) &&
+            (memory_props_.memoryTypes[i].propertyFlags & props) == props) {
+            return i;
+        }
+    }
+    return UINT32_MAX;
+}
+
+// ---------------------------------------------------------------------------
+// Shared image creation
+// ---------------------------------------------------------------------------
+
+bool GaussianSplatVulkanInteropContext::AllocateExportableImage(
+        std::uint32_t width,
+        std::uint32_t height,
+        VkFormat vk_format,
+        VkImageUsageFlags usage,
+        VkImage& out_image,
+        VkDeviceMemory& out_memory,
+        int& out_fd) const {
+    const vk::Format format = static_cast<vk::Format>(vk_format);
+    const vk::ImageUsageFlags vk_usage =
+            static_cast<vk::ImageUsageFlags>(usage);
+
+#if defined(_WIN32)
+    constexpr vk::ExternalMemoryHandleTypeFlagBits kHandleType =
+            vk::ExternalMemoryHandleTypeFlagBits::eOpaqueWin32;
+#else
+    constexpr vk::ExternalMemoryHandleTypeFlagBits kHandleType =
+            vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd;
+#endif
+
+    // Chain external-memory info into the image create info.
+    vk::StructureChain<vk::ImageCreateInfo, vk::ExternalMemoryImageCreateInfo>
+            img_chain{
+                    vk::ImageCreateInfo{
+                            {},
+                            vk::ImageType::e2D,
+                            format,
+                            {width, height, 1},
+                            1,
+                            1,
+                            vk::SampleCountFlagBits::e1,
+                            vk::ImageTiling::eOptimal,
+                            vk_usage,
+                            vk::SharingMode::eExclusive,
+                            {},
+                            vk::ImageLayout::eUndefined,
+                    },
+                    vk::ExternalMemoryImageCreateInfo{kHandleType},
+            };
+
+    // Use the non-RAII vk::Device wrapper: AllocateExportableImage manages raw
+    // VkImage/VkDeviceMemory lifetimes explicitly (exported to GL via FD).
+    const vk::Device dev(*device_);
+
+    vk::Image image;
+    try {
+        image = dev.createImage(img_chain.get<vk::ImageCreateInfo>());
+    } catch (const vk::SystemError& e) {
+        utility::LogWarning("GaussianSplat Vulkan: vkCreateImage failed: {}",
+                            e.what());
+        return false;
+    }
+
+    const vk::MemoryRequirements mem_req =
+            dev.getImageMemoryRequirements(image);
+    const std::uint32_t mem_type =
+            FindMemoryType(mem_req.memoryTypeBits,
+                           static_cast<VkMemoryPropertyFlags>(
+                                   vk::MemoryPropertyFlagBits::eDeviceLocal));
+    if (mem_type == UINT32_MAX) {
+        utility::LogWarning(
+                "GaussianSplat Vulkan: no suitable device-local memory type");
+        dev.destroyImage(image);
+        return false;
+    }
+
+    // Chain dedicated-alloc and export-alloc info into vk::MemoryAllocateInfo.
+    vk::StructureChain<vk::MemoryAllocateInfo, vk::ExportMemoryAllocateInfo,
+                       vk::MemoryDedicatedAllocateInfo>
+            mem_chain{
+                    vk::MemoryAllocateInfo{mem_req.size, mem_type},
+                    vk::ExportMemoryAllocateInfo{kHandleType},
+                    vk::MemoryDedicatedAllocateInfo{image},
+            };
+
+    vk::DeviceMemory memory;
+    try {
+        memory = dev.allocateMemory(mem_chain.get<vk::MemoryAllocateInfo>());
+    } catch (const vk::SystemError& e) {
+        utility::LogWarning("GaussianSplat Vulkan: vkAllocateMemory failed: {}",
+                            e.what());
+        dev.destroyImage(image);
+        return false;
+    }
+
+    try {
+        (void)dev.bindImageMemory(image, memory, 0);
+    } catch (const vk::SystemError& e) {
+        utility::LogWarning(
+                "GaussianSplat Vulkan: vkBindImageMemory failed: {}", e.what());
+        dev.freeMemory(memory);
+        dev.destroyImage(image);
+        return false;
+    }
+
+    // Export the memory as a platform handle.
+#if defined(_WIN32)
+    HANDLE win32_handle = nullptr;
+    try {
+        win32_handle = dev.getMemoryWin32HandleKHR(
+                {memory, vk::ExternalMemoryHandleTypeFlagBits::eOpaqueWin32});
+    } catch (const vk::SystemError& e) {
+        utility::LogWarning(
+                "GaussianSplat Vulkan: vkGetMemoryWin32HandleKHR failed: {}",
+                e.what());
+        dev.freeMemory(memory);
+        dev.destroyImage(image);
+        return false;
+    }
+    out_fd = static_cast<int>(reinterpret_cast<intptr_t>(win32_handle));
+    // NOTE: on Windows, HANDLE values are not real file descriptors and should
+    // be closed with CloseHandle() after being imported into GL. However, the
+    // current design passes them as int (out_fd) to ImportFDIntoGL, which will
+    // pass them to glImportMemoryWin32HandleEXT. GL takes ownership of the
+    // HANDLE import, so we cannot close it here. The HANDLE lifetime is managed
+    // by GL and Vulkan.
+#else
+    try {
+        out_fd = dev.getMemoryFdKHR(
+                {memory, vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd});
+    } catch (const vk::SystemError& e) {
+        utility::LogWarning("GaussianSplat Vulkan: vkGetMemoryFdKHR failed: {}",
+                            e.what());
+        dev.freeMemory(memory);
+        dev.destroyImage(image);
+        return false;
+    }
+#endif
+
+    out_image = static_cast<VkImage>(image);
+    out_memory = static_cast<VkDeviceMemory>(memory);
+    return true;
+}
+
+bool GaussianSplatVulkanInteropContext::ImportFDIntoGL(
+        int fd,
+        std::uint32_t width,
+        std::uint32_t height,
+        VkDeviceSize memory_size,
+        VkInteropImageFormat format,
+        std::uint32_t& out_gl_memory_object,
+        std::uint32_t& out_gl_texture) const {
+    // Create a GL memory object and import the Vulkan FD into it.
+    glCreateMemoryObjectsEXT(1, &out_gl_memory_object);
+    if (out_gl_memory_object == 0) {
+        utility::LogWarning(
+                "GaussianSplat GL: glCreateMemoryObjectsEXT returned 0");
+        return false;
+    }
+
+#if defined(_WIN32)
+    const HANDLE win32_handle =
+            reinterpret_cast<HANDLE>(static_cast<intptr_t>(fd));
+    glImportMemoryWin32HandleEXT(out_gl_memory_object,
+                                 static_cast<GLuint64>(memory_size),
+                                 GL_HANDLE_TYPE_OPAQUE_WIN32_EXT, win32_handle);
+    // IMPORTANT: On Windows, vkGetMemoryWin32HandleKHR() returns a new HANDLE
+    // that we own. glImportMemoryWin32HandleEXT() makes a copy internally. We
+    // must close the returned HANDLE to avoid kernel handle resource leaks.
+    CloseHandle(win32_handle);
+#else
+    glImportMemoryFdEXT(out_gl_memory_object,
+                        static_cast<GLuint64>(memory_size),
+                        GL_HANDLE_TYPE_OPAQUE_FD_EXT, fd);
+    // FD ownership is transferred to GL; do not close it.
+#endif
+
+    // Create a GL texture backed by the imported memory object.
+    glCreateTextures(GL_TEXTURE_2D, 1, &out_gl_texture);
+    if (out_gl_texture == 0) {
+        glDeleteMemoryObjectsEXT(1, &out_gl_memory_object);
+        out_gl_memory_object = 0;
+        utility::LogWarning("GaussianSplat GL: glCreateTextures returned 0");
+        return false;
+    }
+
+    // Allocate GL texture storage bound to the imported memory.
+    GLenum gl_internal_format = 0;
+    switch (format) {
+        case VkInteropImageFormat::kRGBA16F:
+            gl_internal_format = GL_RGBA16F;
+            break;
+        case VkInteropImageFormat::kDepth32F:
+            gl_internal_format = GL_DEPTH_COMPONENT32F;
+            break;
+    }
+    glTextureStorageMem2DEXT(
+            out_gl_texture, 1, gl_internal_format, static_cast<GLsizei>(width),
+            static_cast<GLsizei>(height), out_gl_memory_object, /*offset=*/0);
+
+    const GLenum err = glGetError();
+    if (err != GL_NO_ERROR) {
+        utility::LogWarning(
+                "GaussianSplat GL: glTextureStorageMem2DEXT error 0x{:x}",
+                static_cast<unsigned>(err));
+        glDeleteTextures(1, &out_gl_texture);
+        glDeleteMemoryObjectsEXT(1, &out_gl_memory_object);
+        out_gl_texture = 0;
+        out_gl_memory_object = 0;
+        return false;
+    }
+    return true;
+}
+
+SharedImageDesc GaussianSplatVulkanInteropContext::CreateSharedImage(
+        std::uint32_t width,
+        std::uint32_t height,
+        VkInteropImageFormat interop_format,
+        const char* label) {
+    SharedImageDesc desc{};
+    if (!initialized_ || !gl_extensions_ok_) {
+        utility::LogWarning(
+                "GaussianSplat Vulkan: CreateSharedImage called before "
+                "Initialize()+ProbeGLExtensions()");
+        return desc;
+    }
+
+    VkFormat vk_fmt = VK_FORMAT_UNDEFINED;
+    VkImageUsageFlags usage = 0;
+    switch (interop_format) {
+        case VkInteropImageFormat::kRGBA16F:
+            vk_fmt = VK_FORMAT_R16G16B16A16_SFLOAT;
+            // STORAGE for compute write; SAMPLED for Filament/UI read;
+            // COLOR_ATTACHMENT: required for Filament COLOR_ATTACHMENT usage.
+            usage = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
+                    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                    VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+            break;
+        case VkInteropImageFormat::kDepth32F:
+            vk_fmt = VK_FORMAT_D32_SFLOAT;
+            // DEPTH_STENCIL_ATTACHMENT: Filament writes depth into it.
+            // SAMPLED: Vulkan composite pass samples it for occlusion.
+            usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+                    VK_IMAGE_USAGE_SAMPLED_BIT;
+            break;
+    }
+
+    int export_fd = -1;
+    {
+        // Probe memory requirements using a temporary image (no exportable
+        // memory yet) to determine the actual allocation size for GL import.
+        vk::ImageCreateInfo probe_ci{{},
+                                     vk::ImageType::e2D,
+                                     static_cast<vk::Format>(vk_fmt),
+                                     {width, height, 1},
+                                     1,
+                                     1,
+                                     vk::SampleCountFlagBits::e1,
+                                     vk::ImageTiling::eOptimal,
+                                     static_cast<vk::ImageUsageFlags>(usage)};
+        try {
+            vk::Image probe_img = vk::Device(*device_).createImage(probe_ci);
+            vk::Device(*device_).destroyImage(probe_img);
+        } catch (...) {
+            // Ignore probe failures; AllocateExportableImage will report.
+        }
+    }
+
+    bool ok = AllocateExportableImage(width, height, vk_fmt, usage,
+                                      desc.vk_image, desc.vk_memory, export_fd);
+    if (!ok) return desc;
+
+    // Query actual memory size for the GL import call.
+    const vk::MemoryRequirements actual_req =
+            vk::Device(*device_).getImageMemoryRequirements(
+                    static_cast<vk::Image>(desc.vk_image));
+
+    ok = ImportFDIntoGL(export_fd, width, height,
+                        static_cast<VkDeviceSize>(actual_req.size),
+                        interop_format, desc.gl_memory_object, desc.gl_texture);
+    if (!ok) {
+        vk::Device(*device_).freeMemory(
+                static_cast<vk::DeviceMemory>(desc.vk_memory));
+        vk::Device(*device_).destroyImage(
+                static_cast<vk::Image>(desc.vk_image));
+        desc = SharedImageDesc{};
+        return desc;
+    }
+
+    desc.width = width;
+    desc.height = height;
+    desc.format = interop_format;
+    desc.current_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+    if (label) {
+        utility::LogDebug(
+                "GaussianSplat Vulkan: created shared image '{}' "
+                "{}x{} GL={}",
+                label, width, height, desc.gl_texture);
+    }
+    return desc;
+}
+
+SharedImageDesc GaussianSplatVulkanInteropContext::CreateSharedColorImage(
+        std::uint32_t width, std::uint32_t height, const char* label) {
+    return CreateSharedImage(width, height, VkInteropImageFormat::kRGBA16F,
+                             label);
+}
+
+SharedImageDesc GaussianSplatVulkanInteropContext::CreateSharedDepthImage(
+        std::uint32_t width, std::uint32_t height, const char* label) {
+    return CreateSharedImage(width, height, VkInteropImageFormat::kDepth32F,
+                             label);
+}
+
+void GaussianSplatVulkanInteropContext::DestroySharedImage(
+        SharedImageDesc& desc) {
+    if (!desc.IsValid()) return;
+
+    // GL objects must be destroyed before the underlying Vulkan memory.
+    if (desc.gl_texture != 0) {
+        glDeleteTextures(1, &desc.gl_texture);
+        desc.gl_texture = 0;
+    }
+    if (desc.gl_memory_object != 0) {
+        glDeleteMemoryObjectsEXT(1, &desc.gl_memory_object);
+        desc.gl_memory_object = 0;
+    }
+    // Now safe to free Vulkan resources.
+    if (desc.vk_image != VK_NULL_HANDLE) {
+        vk::Device(*device_).destroyImage(
+                static_cast<vk::Image>(desc.vk_image));
+        desc.vk_image = VK_NULL_HANDLE;
+    }
+    if (desc.vk_memory != VK_NULL_HANDLE) {
+        vk::Device(*device_).freeMemory(
+                static_cast<vk::DeviceMemory>(desc.vk_memory));
+        desc.vk_memory = VK_NULL_HANDLE;
+    }
+    desc = SharedImageDesc{};
+}
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
+
+#endif  // !defined(__APPLE__)
diff --git a/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.h b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.h
new file mode 100644
index 00000000000..e7927feae41
--- /dev/null
+++ b/cpp/open3d/visualization/rendering/gaussian_splat/GaussianSplatVulkanInteropContext.h
@@ -0,0 +1,267 @@
+// ----------------------------------------------------------------------------
+// -                        Open3D: www.open3d.org                            -
+// ----------------------------------------------------------------------------
+// Copyright (c) 2018-2024 www.open3d.org
+// SPDX-License-Identifier: MIT
+// ----------------------------------------------------------------------------
+//
+// Vulkan-OpenGL interop context for Gaussian splatting compute (Linux/Windows).
+//
+// Owns a headless Vulkan instance and logical device used solely for compute
+// work. All resources that must be visible to both Vulkan compute and
+// OpenGL/Filament are allocated here as exportable memory objects.
+//
+// Key relationships:
+//   - GaussianSplatOpenGLContext creates the GL/GLFW context and calls
+//     glewInit(). After that, call ProbeGLExtensions() to verify the
+//     GL interop extensions are present.
+//   - FilamentEngine.cpp calls Initialize() before GL context setup, and
+//     Shutdown() on engine teardown.
+//   - GaussianSplatVulkanBackend uses CreateSharedColorImage() and
+//     CreateSharedDepthImage() per view, holding the handles in OutputTargets.
+//
+// Uses vulkan-hpp (Vulkan-Headers) for Vulkan loading and RAII handle
+// lifetime management, and VMA (vk_mem_alloc.h from the pinned 3rdparty
+// download) for suballocated internal-only buffer allocations.
+//
+// Thread-safety: not thread-safe. All calls must be made from the render
+// thread. Shared images must be created or destroyed while the GL context is
+// current (for the GL import calls).
+
+#pragma once
+
+#if !defined(__APPLE__)
+
+#include <cstdint>
+#include <string>
+
+// Suppress C function-prototype declarations in vulkan.h: all Vulkan entry
+// points are resolved at runtime through vulkan-hpp's per-object RAII
+// dispatchers (ContextDispatcher / InstanceDispatcher / DeviceDispatcher),
+// not as statically-linked symbols.
+//
+// NOTE: BlueVK (used by Filament) also defines VK_NO_PROTOTYPES before
+// including vulkan.h, so the two includes are mutually compatible when
+// this header is included after Filament headers.
+#ifndef VK_NO_PROTOTYPES
+#define VK_NO_PROTOTYPES
+#endif
+#include <vulkan/vulkan_raii.hpp>
+
+namespace open3d {
+namespace visualization {
+namespace rendering {
+
+// ---------------------------------------------------------------------------
+// Shared resource descriptors
+// ---------------------------------------------------------------------------
+
+/// Image format selector used for interop image creation.
+enum class VkInteropImageFormat {
+    kRGBA16F,   ///< RGBA16F colour (VK_FORMAT_R16G16B16A16_SFLOAT / GL RGBA16F)
+    kDepth32F,  ///< Depth-only (VK_FORMAT_D32_SFLOAT / GL DEPTH_COMPONENT32F)
+};
+
+/// Describes a single GPU image that is owned by Vulkan but visible to OpenGL
+/// via the EXT_memory_object mechanism.
+///
+/// Lifetimesemantics:
+///   1. CreateSharedColorImage() / CreateSharedDepthImage() allocates the
+///      Vulkan image with a dedicated exportable allocation and simultaneously
+///      imports it into OpenGL, returning a fully-initialised SharedImageDesc.
+///   2. The gl_texture name (uint32_t) is passed to
+///      FilamentResourceManager::CreateImportedTexture() exactly as today.
+///   3. DestroySharedImage() first deletes the GL memory-object and texture,
+///      then the Vulkan image and memory.
+struct SharedImageDesc {
+    VkImage vk_image = VK_NULL_HANDLE;
+    VkDeviceMemory vk_memory = VK_NULL_HANDLE;  ///< Dedicated exportable alloc
+
+    /// OpenGL objects wrapping the exported memory. These have a lifetime
+    /// equal to vk_memory; destroy them before vkFreeMemory.
+    std::uint32_t gl_memory_object = 0;  ///< glCreateMemoryObjectsEXT result
+    std::uint32_t gl_texture = 0;        ///< GL texture name; pass to Filament
+
+    /// Dimensions and format (stored for resize/recreate checks).
+    std::uint32_t width = 0;
+    std::uint32_t height = 0;
+    VkInteropImageFormat format = VkInteropImageFormat::kRGBA16F;
+
+    /// Vulkan image layout currently assumed by the Vulkan side. Updated after
+    /// each VkImageMemoryBarrier.
+    VkImageLayout current_layout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+    bool IsValid() const { return vk_image != VK_NULL_HANDLE; }
+};
+
+// ---------------------------------------------------------------------------
+// GaussianSplatVulkanInteropContext — headless Vulkan compute context
+// ---------------------------------------------------------------------------
+
+/// Manages a headless Vulkan instance, physical device selection, and logical
+/// device for OpenGL-Vulkan interop in the GaussianSplat compute pipeline.
+///
+/// Singleton, parallel to GaussianSplatOpenGLContext. Initialize() must be
+/// called before the OpenGL context because the GL-Vulkan interop texture
+/// import path needs both contexts alive simultaneously.
+class GaussianSplatVulkanInteropContext {
+public:
+    static GaussianSplatVulkanInteropContext& GetInstance();
+
+    /// Load Vulkan via BlueVK, select a physical device with external-memory
+    /// extension support, and create a compute queue.
+    /// Must be called BEFORE
+    /// GaussianSplatOpenGLContext::InitializeStandalone(). Returns false on
+    /// failure; call GetLastError() for a diagnostic string.
+    bool Initialize();
+
+    /// Release all Vulkan resources and invalidate the context.
+    void Shutdown();
+
+    bool IsValid() const { return initialized_; }
+
+    /// Call this once after glewInit() to verify all required GL interop
+    /// extension entry points are present. Returns false and sets the last
+    /// error string if any required extension is missing.
+    bool ProbeGLExtensions();
+
+    bool AreGLExtensionsReady() const { return gl_extensions_ok_; }
+
+    /// Human-readable description of the last failure (extension name, etc.).
+    const std::string& GetLastError() const { return last_error_; }
+
+    // --- Device accessors (used by VulkanBackend and ComputeGPUVulkan) ----
+    // vk::Handle::CType provides the underlying C type (e.g.
+    // vk::Instance::CType
+    // == VkInstance). On 64-bit platforms vk::raii handles implicitly convert
+    // to their C equivalents; static_cast is used here to be explicit and
+    // 32-bit safe.
+    VkInstance GetVkInstance() const {
+        return static_cast<vk::Instance::CType>(*instance_);
+    }
+    VkDevice GetDevice() const {
+        return static_cast<vk::Device::CType>(*device_);
+    }
+    VkPhysicalDevice GetPhysicalDevice() const {
+        return static_cast<vk::PhysicalDevice::CType>(*physical_device_);
+    }
+    VkQueue GetComputeQueue() const {
+        return static_cast<vk::Queue::CType>(*compute_queue_);
+    }
+    std::uint32_t GetComputeQueueFamily() const {
+        return compute_queue_family_;
+    }
+    /// True when VK_EXT_debug_utils was available and enabled at instance
+    /// creation.
+    bool GetDebugUtilsEnabled() const { return debug_utils_enabled_; }
+    /// Hardware subgroup size (gl_SubgroupSize) for compute shaders on this
+    /// device. Returns 0 before Initialize().
+    std::uint32_t GetSubgroupSize() const { return subgroup_size_; }
+    std::uint32_t GetSubgroupSupportedStages() const {
+        return subgroup_supported_stages_;
+    }
+    std::uint32_t GetSubgroupSupportedOperations() const {
+        return subgroup_supported_operations_;
+    }
+
+    // RAII accessors used by ComputeGPUVulkan to create sub-objects.
+    const vk::raii::Instance& GetRaiiInstance() const { return instance_; }
+    const vk::raii::Device& GetRaiiDevice() const { return device_; }
+
+    // --- Shared-image lifecycle -------------------------------------------
+
+    /// Allocate a Vulkan RGBA16F colour image with a dedicated exportable
+    /// memory allocation, export the FD, and import into an OpenGL texture
+    /// via EXT_memory_object. Requires the GL context to be current.
+    /// Returns an invalid (IsValid()==false) descriptor on failure.
+    SharedImageDesc CreateSharedColorImage(std::uint32_t width,
+                                           std::uint32_t height,
+                                           const char* label = nullptr);
+
+    /// Same as CreateSharedColorImage() but allocates a DEPTH32F image
+    /// suitable for Filament DEPTH_ATTACHMENT | SAMPLEABLE usage.
+    SharedImageDesc CreateSharedDepthImage(std::uint32_t width,
+                                           std::uint32_t height,
+                                           const char* label = nullptr);
+
+    /// Destroy a shared image: delete GL texture / memory-object, then free
+    /// the Vulkan image and device memory.
+    /// Requires the GL context to be current.
+    void DestroySharedImage(SharedImageDesc& desc);
+
+    // --- Vulkan device memory type helpers --------------------------------
+
+    /// Find a memory type index that satisfies type_filter (bitmask from
+    /// VkMemoryRequirements) and the required property flags.
+    /// Returns UINT32_MAX on failure.
+    std::uint32_t FindMemoryType(std::uint32_t type_filter,
+                                 VkMemoryPropertyFlags props) const;
+
+private:
+    GaussianSplatVulkanInteropContext() = default;
+    ~GaussianSplatVulkanInteropContext();
+
+    GaussianSplatVulkanInteropContext(
+            const GaussianSplatVulkanInteropContext&) = delete;
+    GaussianSplatVulkanInteropContext& operator=(
+            const GaussianSplatVulkanInteropContext&) = delete;
+
+    // --- Internal helpers -------------------------------------------------
+
+    bool CreateInstance();
+    bool SelectPhysicalDevice();
+    bool CreateLogicalDevice();
+
+    /// Allocate a VkImage with a dedicated exportable memory allocation and
+    /// export the platform file descriptor. Returns VK_NULL_HANDLE on failure.
+    bool AllocateExportableImage(std::uint32_t width,
+                                 std::uint32_t height,
+                                 VkFormat vk_format,
+                                 VkImageUsageFlags usage,
+                                 VkImage& out_image,
+                                 VkDeviceMemory& out_memory,
+                                 int& out_fd) const;
+
+    /// Import a Vulkan FD into an OpenGL memory-object and create a GL
+    /// texture backed by that memory object.
+    bool ImportFDIntoGL(int fd,
+                        std::uint32_t width,
+                        std::uint32_t height,
+                        VkDeviceSize memory_size,
+                        VkInteropImageFormat format,
+                        std::uint32_t& out_gl_memory_object,
+                        std::uint32_t& out_gl_texture) const;
+
+    SharedImageDesc CreateSharedImage(std::uint32_t width,
+                                      std::uint32_t height,
+                                      VkInteropImageFormat format,
+                                      const char* label);
+
+    // --- State ------------------------------------------------------------
+    bool initialized_ = false;
+    bool gl_extensions_ok_ = false;
+    bool debug_utils_enabled_ =
+            false;                     // VK_EXT_debug_utils enabled in instance
+    std::uint32_t subgroup_size_ = 0;  // queried after logical device creation
+    std::uint32_t subgroup_supported_stages_ = 0;
+    std::uint32_t subgroup_supported_operations_ = 0;
+    std::string last_error_;
+
+    // RAII handles. Destruction order is reverse of declaration order:
+    // compute_queue_ → device_ → physical_device_ → instance_ → context_.
+    // vk::raii::Context loads the Vulkan loader; all others are sub-objects.
+    vk::raii::Context context_;
+    vk::raii::Instance instance_{nullptr};
+    vk::raii::PhysicalDevice physical_device_{nullptr};
+    vk::raii::Device device_{nullptr};
+    vk::raii::Queue compute_queue_{nullptr};
+    std::uint32_t compute_queue_family_ = UINT32_MAX;
+
+    VkPhysicalDeviceMemoryProperties memory_props_{};
+};
+
+}  // namespace rendering
+}  // namespace visualization
+}  // namespace open3d
+
+#endif  // !defined(__APPLE__)
diff --git a/util/check_cpp_style.cmake b/util/check_cpp_style.cmake
index b19a80f9a25..940345ef39b 100644
--- a/util/check_cpp_style.cmake
+++ b/util/check_cpp_style.cmake
@@ -65,6 +65,10 @@ foreach(DIRECTORY ${CPP_FORMAT_DIRS})
         "${PROJECT_SOURCE_DIR}/${DIRECTORY}/*.ispc"
         # Generated files
         "${PROJECT_SOURCE_DIR}/${DIRECTORY}/*.h.in"
+        # Objective-C++
+        "${PROJECT_SOURCE_DIR}/${DIRECTORY}/*.mm"
+        # GLSL compute shaders
+        "${PROJECT_SOURCE_DIR}/${DIRECTORY}/*.comp"
     )
     set(IGNOFRED_FILES
         "${PROJECT_SOURCE_DIR}/cpp/open3d/visualization/shader/Shader.h"
diff --git a/util/check_style.py b/util/check_style.py
index 500a90deb8a..dc5abe91a61 100644
--- a/util/check_style.py
+++ b/util/check_style.py
@@ -356,8 +356,9 @@ def main():
     python_style_config = str(pwd.parent / ".style.yapf")
 
     cpp_ignored_files = ['cpp/open3d/visualization/shader/Shader.h']
-    cpp_files = _glob_files(CPP_FORMAT_DIRS,
-                            ["h", "cpp", "cuh", "cu", "isph", "ispc", "h.in"])
+    cpp_files = _glob_files(
+        CPP_FORMAT_DIRS,
+        ["h", "cpp", "cuh", "cu", "isph", "ispc", "h.in", "mm", "comp"])
     cpp_files = _filter_files(cpp_files, cpp_ignored_files)
 
     # Check or apply style