Thirdparty includes flagged as SYSTEM

3 files changed, 27814 insertions, 0 deletions

diff --git a/thirdparty/renderdoc.h b/thirdparty/renderdoc.h
new file mode 100644
index 0000000..075306c
--- /dev/null
+++ b/thirdparty/renderdoc.h
@@ -0,0 +1,688 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019-2020 Baldur Karlsson
+ *
+ * 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.
+ ******************************************************************************/
+
+#pragma once
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Documentation for the API is available at https://renderdoc.org/docs/in_application_api.html
+//
+
+#if !defined(RENDERDOC_NO_STDINT)
+#include <stdint.h>
+#endif
+
+#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define RENDERDOC_CC __cdecl
+#elif defined(__linux__)
+#define RENDERDOC_CC
+#elif defined(__APPLE__)
+#define RENDERDOC_CC
+#else
+#error "Unknown platform"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// Constants not used directly in below API
+
+// This is a GUID/magic value used for when applications pass a path where shader debug
+// information can be found to match up with a stripped shader.
+// the define can be used like so: const GUID RENDERDOC_ShaderDebugMagicValue =
+// RENDERDOC_ShaderDebugMagicValue_value
+#define RENDERDOC_ShaderDebugMagicValue_struct                                \
+  {                                                                           \
+    0xeab25520, 0x6670, 0x4865, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
+  }
+
+// as an alternative when you want a byte array (assuming x86 endianness):
+#define RENDERDOC_ShaderDebugMagicValue_bytearray                                                 \
+  {                                                                                               \
+    0x20, 0x55, 0xb2, 0xea, 0x70, 0x66, 0x65, 0x48, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
+  }
+
+// truncated version when only a uint64_t is available (e.g. Vulkan tags):
+#define RENDERDOC_ShaderDebugMagicValue_truncated 0x48656670eab25520ULL
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc capture options
+//
+
+typedef enum RENDERDOC_CaptureOption {
+  // Allow the application to enable vsync
+  //
+  // Default - enabled
+  //
+  // 1 - The application can enable or disable vsync at will
+  // 0 - vsync is force disabled
+  eRENDERDOC_Option_AllowVSync = 0,
+
+  // Allow the application to enable fullscreen
+  //
+  // Default - enabled
+  //
+  // 1 - The application can enable or disable fullscreen at will
+  // 0 - fullscreen is force disabled
+  eRENDERDOC_Option_AllowFullscreen = 1,
+
+  // Record API debugging events and messages
+  //
+  // Default - disabled
+  //
+  // 1 - Enable built-in API debugging features and records the results into
+  //     the capture, which is matched up with events on replay
+  // 0 - no API debugging is forcibly enabled
+  eRENDERDOC_Option_APIValidation = 2,
+  eRENDERDOC_Option_DebugDeviceMode = 2,    // deprecated name of this enum
+
+  // Capture CPU callstacks for API events
+  //
+  // Default - disabled
+  //
+  // 1 - Enables capturing of callstacks
+  // 0 - no callstacks are captured
+  eRENDERDOC_Option_CaptureCallstacks = 3,
+
+  // When capturing CPU callstacks, only capture them from drawcalls.
+  // This option does nothing without the above option being enabled
+  //
+  // Default - disabled
+  //
+  // 1 - Only captures callstacks for drawcall type API events.
+  //     Ignored if CaptureCallstacks is disabled
+  // 0 - Callstacks, if enabled, are captured for every event.
+  eRENDERDOC_Option_CaptureCallstacksOnlyDraws = 4,
+
+  // Specify a delay in seconds to wait for a debugger to attach, after
+  // creating or injecting into a process, before continuing to allow it to run.
+  //
+  // 0 indicates no delay, and the process will run immediately after injection
+  //
+  // Default - 0 seconds
+  //
+  eRENDERDOC_Option_DelayForDebugger = 5,
+
+  // Verify buffer access. This includes checking the memory returned by a Map() call to
+  // detect any out-of-bounds modification, as well as initialising buffers with undefined contents
+  // to a marker value to catch use of uninitialised memory.
+  //
+  // NOTE: This option is only valid for OpenGL and D3D11. Explicit APIs such as D3D12 and Vulkan do
+  // not do the same kind of interception & checking and undefined contents are really undefined.
+  //
+  // Default - disabled
+  //
+  // 1 - Verify buffer access
+  // 0 - No verification is performed, and overwriting bounds may cause crashes or corruption in
+  //     RenderDoc.
+  eRENDERDOC_Option_VerifyBufferAccess = 6,
+
+  // The old name for eRENDERDOC_Option_VerifyBufferAccess was eRENDERDOC_Option_VerifyMapWrites.
+  // This option now controls the filling of uninitialised buffers with 0xdddddddd which was
+  // previously always enabled
+  eRENDERDOC_Option_VerifyMapWrites = eRENDERDOC_Option_VerifyBufferAccess,
+
+  // Hooks any system API calls that create child processes, and injects
+  // RenderDoc into them recursively with the same options.
+  //
+  // Default - disabled
+  //
+  // 1 - Hooks into spawned child processes
+  // 0 - Child processes are not hooked by RenderDoc
+  eRENDERDOC_Option_HookIntoChildren = 7,
+
+  // By default RenderDoc only includes resources in the final capture necessary
+  // for that frame, this allows you to override that behaviour.
+  //
+  // Default - disabled
+  //
+  // 1 - all live resources at the time of capture are included in the capture
+  //     and available for inspection
+  // 0 - only the resources referenced by the captured frame are included
+  eRENDERDOC_Option_RefAllResources = 8,
+
+  // **NOTE**: As of RenderDoc v1.1 this option has been deprecated. Setting or
+  // getting it will be ignored, to allow compatibility with older versions.
+  // In v1.1 the option acts as if it's always enabled.
+  //
+  // By default RenderDoc skips saving initial states for resources where the
+  // previous contents don't appear to be used, assuming that writes before
+  // reads indicate previous contents aren't used.
+  //
+  // Default - disabled
+  //
+  // 1 - initial contents at the start of each captured frame are saved, even if
+  //     they are later overwritten or cleared before being used.
+  // 0 - unless a read is detected, initial contents will not be saved and will
+  //     appear as black or empty data.
+  eRENDERDOC_Option_SaveAllInitials = 9,
+
+  // In APIs that allow for the recording of command lists to be replayed later,
+  // RenderDoc may choose to not capture command lists before a frame capture is
+  // triggered, to reduce overheads. This means any command lists recorded once
+  // and replayed many times will not be available and may cause a failure to
+  // capture.
+  //
+  // NOTE: This is only true for APIs where multithreading is difficult or
+  // discouraged. Newer APIs like Vulkan and D3D12 will ignore this option
+  // and always capture all command lists since the API is heavily oriented
+  // around it and the overheads have been reduced by API design.
+  //
+  // 1 - All command lists are captured from the start of the application
+  // 0 - Command lists are only captured if their recording begins during
+  //     the period when a frame capture is in progress.
+  eRENDERDOC_Option_CaptureAllCmdLists = 10,
+
+  // Mute API debugging output when the API validation mode option is enabled
+  //
+  // Default - enabled
+  //
+  // 1 - Mute any API debug messages from being displayed or passed through
+  // 0 - API debugging is displayed as normal
+  eRENDERDOC_Option_DebugOutputMute = 11,
+
+  // Option to allow vendor extensions to be used even when they may be
+  // incompatible with RenderDoc and cause corrupted replays or crashes.
+  //
+  // Default - inactive
+  //
+  // No values are documented, this option should only be used when absolutely
+  // necessary as directed by a RenderDoc developer.
+  eRENDERDOC_Option_AllowUnsupportedVendorExtensions = 12,
+
+} RENDERDOC_CaptureOption;
+
+// Sets an option that controls how RenderDoc behaves on capture.
+//
+// Returns 1 if the option and value are valid
+// Returns 0 if either is invalid and the option is unchanged
+typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionU32)(RENDERDOC_CaptureOption opt, uint32_t val);
+typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionF32)(RENDERDOC_CaptureOption opt, float val);
+
+// Gets the current value of an option as a uint32_t
+//
+// If the option is invalid, 0xffffffff is returned
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionU32)(RENDERDOC_CaptureOption opt);
+
+// Gets the current value of an option as a float
+//
+// If the option is invalid, -FLT_MAX is returned
+typedef float(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionF32)(RENDERDOC_CaptureOption opt);
+
+typedef enum RENDERDOC_InputButton {
+  // '0' - '9' matches ASCII values
+  eRENDERDOC_Key_0 = 0x30,
+  eRENDERDOC_Key_1 = 0x31,
+  eRENDERDOC_Key_2 = 0x32,
+  eRENDERDOC_Key_3 = 0x33,
+  eRENDERDOC_Key_4 = 0x34,
+  eRENDERDOC_Key_5 = 0x35,
+  eRENDERDOC_Key_6 = 0x36,
+  eRENDERDOC_Key_7 = 0x37,
+  eRENDERDOC_Key_8 = 0x38,
+  eRENDERDOC_Key_9 = 0x39,
+
+  // 'A' - 'Z' matches ASCII values
+  eRENDERDOC_Key_A = 0x41,
+  eRENDERDOC_Key_B = 0x42,
+  eRENDERDOC_Key_C = 0x43,
+  eRENDERDOC_Key_D = 0x44,
+  eRENDERDOC_Key_E = 0x45,
+  eRENDERDOC_Key_F = 0x46,
+  eRENDERDOC_Key_G = 0x47,
+  eRENDERDOC_Key_H = 0x48,
+  eRENDERDOC_Key_I = 0x49,
+  eRENDERDOC_Key_J = 0x4A,
+  eRENDERDOC_Key_K = 0x4B,
+  eRENDERDOC_Key_L = 0x4C,
+  eRENDERDOC_Key_M = 0x4D,
+  eRENDERDOC_Key_N = 0x4E,
+  eRENDERDOC_Key_O = 0x4F,
+  eRENDERDOC_Key_P = 0x50,
+  eRENDERDOC_Key_Q = 0x51,
+  eRENDERDOC_Key_R = 0x52,
+  eRENDERDOC_Key_S = 0x53,
+  eRENDERDOC_Key_T = 0x54,
+  eRENDERDOC_Key_U = 0x55,
+  eRENDERDOC_Key_V = 0x56,
+  eRENDERDOC_Key_W = 0x57,
+  eRENDERDOC_Key_X = 0x58,
+  eRENDERDOC_Key_Y = 0x59,
+  eRENDERDOC_Key_Z = 0x5A,
+
+  // leave the rest of the ASCII range free
+  // in case we want to use it later
+  eRENDERDOC_Key_NonPrintable = 0x100,
+
+  eRENDERDOC_Key_Divide,
+  eRENDERDOC_Key_Multiply,
+  eRENDERDOC_Key_Subtract,
+  eRENDERDOC_Key_Plus,
+
+  eRENDERDOC_Key_F1,
+  eRENDERDOC_Key_F2,
+  eRENDERDOC_Key_F3,
+  eRENDERDOC_Key_F4,
+  eRENDERDOC_Key_F5,
+  eRENDERDOC_Key_F6,
+  eRENDERDOC_Key_F7,
+  eRENDERDOC_Key_F8,
+  eRENDERDOC_Key_F9,
+  eRENDERDOC_Key_F10,
+  eRENDERDOC_Key_F11,
+  eRENDERDOC_Key_F12,
+
+  eRENDERDOC_Key_Home,
+  eRENDERDOC_Key_End,
+  eRENDERDOC_Key_Insert,
+  eRENDERDOC_Key_Delete,
+  eRENDERDOC_Key_PageUp,
+  eRENDERDOC_Key_PageDn,
+
+  eRENDERDOC_Key_Backspace,
+  eRENDERDOC_Key_Tab,
+  eRENDERDOC_Key_PrtScrn,
+  eRENDERDOC_Key_Pause,
+
+  eRENDERDOC_Key_Max,
+} RENDERDOC_InputButton;
+
+// Sets which key or keys can be used to toggle focus between multiple windows
+//
+// If keys is NULL or num is 0, toggle keys will be disabled
+typedef void(RENDERDOC_CC *pRENDERDOC_SetFocusToggleKeys)(RENDERDOC_InputButton *keys, int num);
+
+// Sets which key or keys can be used to capture the next frame
+//
+// If keys is NULL or num is 0, captures keys will be disabled
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureKeys)(RENDERDOC_InputButton *keys, int num);
+
+typedef enum RENDERDOC_OverlayBits {
+  // This single bit controls whether the overlay is enabled or disabled globally
+  eRENDERDOC_Overlay_Enabled = 0x1,
+
+  // Show the average framerate over several seconds as well as min/max
+  eRENDERDOC_Overlay_FrameRate = 0x2,
+
+  // Show the current frame number
+  eRENDERDOC_Overlay_FrameNumber = 0x4,
+
+  // Show a list of recent captures, and how many captures have been made
+  eRENDERDOC_Overlay_CaptureList = 0x8,
+
+  // Default values for the overlay mask
+  eRENDERDOC_Overlay_Default = (eRENDERDOC_Overlay_Enabled | eRENDERDOC_Overlay_FrameRate |
+                                eRENDERDOC_Overlay_FrameNumber | eRENDERDOC_Overlay_CaptureList),
+
+  // Enable all bits
+  eRENDERDOC_Overlay_All = ~0U,
+
+  // Disable all bits
+  eRENDERDOC_Overlay_None = 0,
+} RENDERDOC_OverlayBits;
+
+// returns the overlay bits that have been set
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetOverlayBits)();
+// sets the overlay bits with an and & or mask
+typedef void(RENDERDOC_CC *pRENDERDOC_MaskOverlayBits)(uint32_t And, uint32_t Or);
+
+// this function will attempt to remove RenderDoc's hooks in the application.
+//
+// Note: that this can only work correctly if done immediately after
+// the module is loaded, before any API work happens. RenderDoc will remove its
+// injected hooks and shut down. Behaviour is undefined if this is called
+// after any API functions have been called, and there is still no guarantee of
+// success.
+typedef void(RENDERDOC_CC *pRENDERDOC_RemoveHooks)();
+
+// DEPRECATED: compatibility for code compiled against pre-1.4.1 headers.
+typedef pRENDERDOC_RemoveHooks pRENDERDOC_Shutdown;
+
+// This function will unload RenderDoc's crash handler.
+//
+// If you use your own crash handler and don't want RenderDoc's handler to
+// intercede, you can call this function to unload it and any unhandled
+// exceptions will pass to the next handler.
+typedef void(RENDERDOC_CC *pRENDERDOC_UnloadCrashHandler)();
+
+// Sets the capture file path template
+//
+// pathtemplate is a UTF-8 string that gives a template for how captures will be named
+// and where they will be saved.
+//
+// Any extension is stripped off the path, and captures are saved in the directory
+// specified, and named with the filename and the frame number appended. If the
+// directory does not exist it will be created, including any parent directories.
+//
+// If pathtemplate is NULL, the template will remain unchanged
+//
+// Example:
+//
+// SetCaptureFilePathTemplate("my_captures/example");
+//
+// Capture #1 -> my_captures/example_frame123.rdc
+// Capture #2 -> my_captures/example_frame456.rdc
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFilePathTemplate)(const char *pathtemplate);
+
+// returns the current capture path template, see SetCaptureFileTemplate above, as a UTF-8 string
+typedef const char *(RENDERDOC_CC *pRENDERDOC_GetCaptureFilePathTemplate)();
+
+// DEPRECATED: compatibility for code compiled against pre-1.1.2 headers.
+typedef pRENDERDOC_SetCaptureFilePathTemplate pRENDERDOC_SetLogFilePathTemplate;
+typedef pRENDERDOC_GetCaptureFilePathTemplate pRENDERDOC_GetLogFilePathTemplate;
+
+// returns the number of captures that have been made
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetNumCaptures)();
+
+// This function returns the details of a capture, by index. New captures are added
+// to the end of the list.
+//
+// filename will be filled with the absolute path to the capture file, as a UTF-8 string
+// pathlength will be written with the length in bytes of the filename string
+// timestamp will be written with the time of the capture, in seconds since the Unix epoch
+//
+// Any of the parameters can be NULL and they'll be skipped.
+//
+// The function will return 1 if the capture index is valid, or 0 if the index is invalid
+// If the index is invalid, the values will be unchanged
+//
+// Note: when captures are deleted in the UI they will remain in this list, so the
+// capture path may not exist anymore.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCapture)(uint32_t idx, char *filename,
+                                                      uint32_t *pathlength, uint64_t *timestamp);
+
+// Sets the comments associated with a capture file. These comments are displayed in the
+// UI program when opening.
+//
+// filePath should be a path to the capture file to add comments to. If set to NULL or ""
+// the most recent capture file created made will be used instead.
+// comments should be a NULL-terminated UTF-8 string to add as comments.
+//
+// Any existing comments will be overwritten.
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFileComments)(const char *filePath,
+                                                              const char *comments);
+
+// returns 1 if the RenderDoc UI is connected to this application, 0 otherwise
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsTargetControlConnected)();
+
+// DEPRECATED: compatibility for code compiled against pre-1.1.1 headers.
+// This was renamed to IsTargetControlConnected in API 1.1.1, the old typedef is kept here for
+// backwards compatibility with old code, it is castable either way since it's ABI compatible
+// as the same function pointer type.
+typedef pRENDERDOC_IsTargetControlConnected pRENDERDOC_IsRemoteAccessConnected;
+
+// This function will launch the Replay UI associated with the RenderDoc library injected
+// into the running application.
+//
+// if connectTargetControl is 1, the Replay UI will be launched with a command line parameter
+// to connect to this application
+// cmdline is the rest of the command line, as a UTF-8 string. E.g. a captures to open
+// if cmdline is NULL, the command line will be empty.
+//
+// returns the PID of the replay UI if successful, 0 if not successful.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_LaunchReplayUI)(uint32_t connectTargetControl,
+                                                          const char *cmdline);
+
+// RenderDoc can return a higher version than requested if it's backwards compatible,
+// this function returns the actual version returned. If a parameter is NULL, it will be
+// ignored and the others will be filled out.
+typedef void(RENDERDOC_CC *pRENDERDOC_GetAPIVersion)(int *major, int *minor, int *patch);
+
+//////////////////////////////////////////////////////////////////////////
+// Capturing functions
+//
+
+// A device pointer is a pointer to the API's root handle.
+//
+// This would be an ID3D11Device, HGLRC/GLXContext, ID3D12Device, etc
+typedef void *RENDERDOC_DevicePointer;
+
+// A window handle is the OS's native window handle
+//
+// This would be an HWND, GLXDrawable, etc
+typedef void *RENDERDOC_WindowHandle;
+
+// A helper macro for Vulkan, where the device handle cannot be used directly.
+//
+// Passing the VkInstance to this macro will return the RENDERDOC_DevicePointer to use.
+//
+// Specifically, the value needed is the dispatch table pointer, which sits as the first
+// pointer-sized object in the memory pointed to by the VkInstance. Thus we cast to a void** and
+// indirect once.
+#define RENDERDOC_DEVICEPOINTER_FROM_VKINSTANCE(inst) (*((void **)(inst)))
+
+// This sets the RenderDoc in-app overlay in the API/window pair as 'active' and it will
+// respond to keypresses. Neither parameter can be NULL
+typedef void(RENDERDOC_CC *pRENDERDOC_SetActiveWindow)(RENDERDOC_DevicePointer device,
+                                                       RENDERDOC_WindowHandle wndHandle);
+
+// capture the next frame on whichever window and API is currently considered active
+typedef void(RENDERDOC_CC *pRENDERDOC_TriggerCapture)();
+
+// capture the next N frames on whichever window and API is currently considered active
+typedef void(RENDERDOC_CC *pRENDERDOC_TriggerMultiFrameCapture)(uint32_t numFrames);
+
+// When choosing either a device pointer or a window handle to capture, you can pass NULL.
+// Passing NULL specifies a 'wildcard' match against anything. This allows you to specify
+// any API rendering to a specific window, or a specific API instance rendering to any window,
+// or in the simplest case of one window and one API, you can just pass NULL for both.
+//
+// In either case, if there are two or more possible matching (device,window) pairs it
+// is undefined which one will be captured.
+//
+// Note: for headless rendering you can pass NULL for the window handle and either specify
+// a device pointer or leave it NULL as above.
+
+// Immediately starts capturing API calls on the specified device pointer and window handle.
+//
+// If there is no matching thing to capture (e.g. no supported API has been initialised),
+// this will do nothing.
+//
+// The results are undefined (including crashes) if two captures are started overlapping,
+// even on separate devices and/oror windows.
+typedef void(RENDERDOC_CC *pRENDERDOC_StartFrameCapture)(RENDERDOC_DevicePointer device,
+                                                         RENDERDOC_WindowHandle wndHandle);
+
+// Returns whether or not a frame capture is currently ongoing anywhere.
+//
+// This will return 1 if a capture is ongoing, and 0 if there is no capture running
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsFrameCapturing)();
+
+// Ends capturing immediately.
+//
+// This will return 1 if the capture succeeded, and 0 if there was an error capturing.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_EndFrameCapture)(RENDERDOC_DevicePointer device,
+                                                           RENDERDOC_WindowHandle wndHandle);
+
+// Ends capturing immediately and discard any data stored without saving to disk.
+//
+// This will return 1 if the capture was discarded, and 0 if there was an error or no capture
+// was in progress
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_DiscardFrameCapture)(RENDERDOC_DevicePointer device,
+                                                               RENDERDOC_WindowHandle wndHandle);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc API versions
+//
+
+// RenderDoc uses semantic versioning (http://semver.org/).
+//
+// MAJOR version is incremented when incompatible API changes happen.
+// MINOR version is incremented when functionality is added in a backwards-compatible manner.
+// PATCH version is incremented when backwards-compatible bug fixes happen.
+//
+// Note that this means the API returned can be higher than the one you might have requested.
+// e.g. if you are running against a newer RenderDoc that supports 1.0.1, it will be returned
+// instead of 1.0.0. You can check this with the GetAPIVersion entry point
+typedef enum RENDERDOC_Version {
+  eRENDERDOC_API_Version_1_0_0 = 10000,    // RENDERDOC_API_1_0_0 = 1 00 00
+  eRENDERDOC_API_Version_1_0_1 = 10001,    // RENDERDOC_API_1_0_1 = 1 00 01
+  eRENDERDOC_API_Version_1_0_2 = 10002,    // RENDERDOC_API_1_0_2 = 1 00 02
+  eRENDERDOC_API_Version_1_1_0 = 10100,    // RENDERDOC_API_1_1_0 = 1 01 00
+  eRENDERDOC_API_Version_1_1_1 = 10101,    // RENDERDOC_API_1_1_1 = 1 01 01
+  eRENDERDOC_API_Version_1_1_2 = 10102,    // RENDERDOC_API_1_1_2 = 1 01 02
+  eRENDERDOC_API_Version_1_2_0 = 10200,    // RENDERDOC_API_1_2_0 = 1 02 00
+  eRENDERDOC_API_Version_1_3_0 = 10300,    // RENDERDOC_API_1_3_0 = 1 03 00
+  eRENDERDOC_API_Version_1_4_0 = 10400,    // RENDERDOC_API_1_4_0 = 1 04 00
+  eRENDERDOC_API_Version_1_4_1 = 10401,    // RENDERDOC_API_1_4_1 = 1 04 01
+} RENDERDOC_Version;
+
+// API version changelog:
+//
+// 1.0.0 - initial release
+// 1.0.1 - Bugfix: IsFrameCapturing() was returning false for captures that were triggered
+//         by keypress or TriggerCapture, instead of Start/EndFrameCapture.
+// 1.0.2 - Refactor: Renamed eRENDERDOC_Option_DebugDeviceMode to eRENDERDOC_Option_APIValidation
+// 1.1.0 - Add feature: TriggerMultiFrameCapture(). Backwards compatible with 1.0.x since the new
+//         function pointer is added to the end of the struct, the original layout is identical
+// 1.1.1 - Refactor: Renamed remote access to target control (to better disambiguate from remote
+//         replay/remote server concept in replay UI)
+// 1.1.2 - Refactor: Renamed "log file" in function names to just capture, to clarify that these
+//         are captures and not debug logging files. This is the first API version in the v1.0
+//         branch.
+// 1.2.0 - Added feature: SetCaptureFileComments() to add comments to a capture file that will be
+//         displayed in the UI program on load.
+// 1.3.0 - Added feature: New capture option eRENDERDOC_Option_AllowUnsupportedVendorExtensions
+//         which allows users to opt-in to allowing unsupported vendor extensions to function.
+//         Should be used at the user's own risk.
+//         Refactor: Renamed eRENDERDOC_Option_VerifyMapWrites to
+//         eRENDERDOC_Option_VerifyBufferAccess, which now also controls initialisation to
+//         0xdddddddd of uninitialised buffer contents.
+// 1.4.0 - Added feature: DiscardFrameCapture() to discard a frame capture in progress and stop
+//         capturing without saving anything to disk.
+// 1.4.1 - Refactor: Renamed Shutdown to RemoveHooks to better clarify what is happening
+
+typedef struct RENDERDOC_API_1_4_1
+{
+  pRENDERDOC_GetAPIVersion GetAPIVersion;
+
+  pRENDERDOC_SetCaptureOptionU32 SetCaptureOptionU32;
+  pRENDERDOC_SetCaptureOptionF32 SetCaptureOptionF32;
+
+  pRENDERDOC_GetCaptureOptionU32 GetCaptureOptionU32;
+  pRENDERDOC_GetCaptureOptionF32 GetCaptureOptionF32;
+
+  pRENDERDOC_SetFocusToggleKeys SetFocusToggleKeys;
+  pRENDERDOC_SetCaptureKeys SetCaptureKeys;
+
+  pRENDERDOC_GetOverlayBits GetOverlayBits;
+  pRENDERDOC_MaskOverlayBits MaskOverlayBits;
+
+  // Shutdown was renamed to RemoveHooks in 1.4.1.
+  // These unions allow old code to continue compiling without changes
+  union
+  {
+    pRENDERDOC_Shutdown Shutdown;
+    pRENDERDOC_RemoveHooks RemoveHooks;
+  };
+  pRENDERDOC_UnloadCrashHandler UnloadCrashHandler;
+
+  // Get/SetLogFilePathTemplate was renamed to Get/SetCaptureFilePathTemplate in 1.1.2.
+  // These unions allow old code to continue compiling without changes
+  union
+  {
+    // deprecated name
+    pRENDERDOC_SetLogFilePathTemplate SetLogFilePathTemplate;
+    // current name
+    pRENDERDOC_SetCaptureFilePathTemplate SetCaptureFilePathTemplate;
+  };
+  union
+  {
+    // deprecated name
+    pRENDERDOC_GetLogFilePathTemplate GetLogFilePathTemplate;
+    // current name
+    pRENDERDOC_GetCaptureFilePathTemplate GetCaptureFilePathTemplate;
+  };
+
+  pRENDERDOC_GetNumCaptures GetNumCaptures;
+  pRENDERDOC_GetCapture GetCapture;
+
+  pRENDERDOC_TriggerCapture TriggerCapture;
+
+  // IsRemoteAccessConnected was renamed to IsTargetControlConnected in 1.1.1.
+  // This union allows old code to continue compiling without changes
+  union
+  {
+    // deprecated name
+    pRENDERDOC_IsRemoteAccessConnected IsRemoteAccessConnected;
+    // current name
+    pRENDERDOC_IsTargetControlConnected IsTargetControlConnected;
+  };
+  pRENDERDOC_LaunchReplayUI LaunchReplayUI;
+
+  pRENDERDOC_SetActiveWindow SetActiveWindow;
+
+  pRENDERDOC_StartFrameCapture StartFrameCapture;
+  pRENDERDOC_IsFrameCapturing IsFrameCapturing;
+  pRENDERDOC_EndFrameCapture EndFrameCapture;
+
+  // new function in 1.1.0
+  pRENDERDOC_TriggerMultiFrameCapture TriggerMultiFrameCapture;
+
+  // new function in 1.2.0
+  pRENDERDOC_SetCaptureFileComments SetCaptureFileComments;
+
+  // new function in 1.4.0
+  pRENDERDOC_DiscardFrameCapture DiscardFrameCapture;
+} RENDERDOC_API_1_4_1;
+
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_0_0;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_0_1;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_0_2;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_1_0;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_1_1;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_1_2;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_2_0;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_3_0;
+typedef RENDERDOC_API_1_4_1 RENDERDOC_API_1_4_0;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc API entry point
+//
+// This entry point can be obtained via GetProcAddress/dlsym if RenderDoc is available.
+//
+// The name is the same as the typedef - "RENDERDOC_GetAPI"
+//
+// This function is not thread safe, and should not be called on multiple threads at once.
+// Ideally, call this once as early as possible in your application's startup, before doing
+// any API work, since some configuration functionality etc has to be done also before
+// initialising any APIs.
+//
+// Parameters:
+//   version is a single value from the RENDERDOC_Version above.
+//
+//   outAPIPointers will be filled out with a pointer to the corresponding struct of function
+//   pointers.
+//
+// Returns:
+//   1 - if the outAPIPointers has been filled with a pointer to the API struct requested
+//   0 - if the requested version is not supported or the arguments are invalid.
+//
+typedef int(RENDERDOC_CC *pRENDERDOC_GetAPI)(RENDERDOC_Version version, void **outAPIPointers);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
diff --git a/thirdparty/stb_image.h b/thirdparty/stb_image.h
new file mode 100644
index 0000000..ef76fc1
--- /dev/null
+++ b/thirdparty/stb_image.h
@@ -0,0 +1,7897 @@
+/* stb_image - v2.27 - public domain image loader - http://nothings.org/stb

+                                  no warranty implied; use at your own risk

+

+   Do this:

+      #define STB_IMAGE_IMPLEMENTATION

+   before you include this file in *one* C or C++ file to create the implementation.

+

+   // i.e. it should look like this:

+   #include ...

+   #include ...

+   #include ...

+   #define STB_IMAGE_IMPLEMENTATION

+   #include "stb_image.h"

+

+   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.

+   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free

+

+

+   QUICK NOTES:

+      Primarily of interest to game developers and other people who can

+          avoid problematic images and only need the trivial interface

+

+      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)

+      PNG 1/2/4/8/16-bit-per-channel

+

+      TGA (not sure what subset, if a subset)

+      BMP non-1bpp, non-RLE

+      PSD (composited view only, no extra channels, 8/16 bit-per-channel)

+

+      GIF (*comp always reports as 4-channel)

+      HDR (radiance rgbE format)

+      PIC (Softimage PIC)

+      PNM (PPM and PGM binary only)

+

+      Animated GIF still needs a proper API, but here's one way to do it:

+          http://gist.github.com/urraka/685d9a6340b26b830d49

+

+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)

+      - decode from arbitrary I/O callbacks

+      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)

+

+   Full documentation under "DOCUMENTATION" below.

+

+

+LICENSE

+

+  See end of file for license information.

+

+RECENT REVISION HISTORY:

+

+      2.27  (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes

+      2.26  (2020-07-13) many minor fixes

+      2.25  (2020-02-02) fix warnings

+      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically

+      2.23  (2019-08-11) fix clang static analysis warning

+      2.22  (2019-03-04) gif fixes, fix warnings

+      2.21  (2019-02-25) fix typo in comment

+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs

+      2.19  (2018-02-11) fix warning

+      2.18  (2018-01-30) fix warnings

+      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings

+      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes

+      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC

+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs

+      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes

+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes

+      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64

+                         RGB-format JPEG; remove white matting in PSD;

+                         allocate large structures on the stack;

+                         correct channel count for PNG & BMP

+      2.10  (2016-01-22) avoid warning introduced in 2.09

+      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED

+

+   See end of file for full revision history.

+

+

+ ============================    Contributors    =========================

+

+ Image formats                          Extensions, features

+    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)

+    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)

+    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)

+    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)

+    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)

+    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)

+    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)

+    github:urraka (animated gif)           Junggon Kim (PNM comments)

+    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)

+                                           socks-the-fox (16-bit PNG)

+                                           Jeremy Sawicki (handle all ImageNet JPGs)

+ Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)

+    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)

+    Arseny Kapoulkine                      Simon Breuss (16-bit PNM)

+    John-Mark Allen

+    Carmelo J Fdez-Aguera

+

+ Bug & warning fixes

+    Marc LeBlanc            David Woo          Guillaume George     Martins Mozeiko

+    Christpher Lloyd        Jerry Jansson      Joseph Thomson       Blazej Dariusz Roszkowski

+    Phil Jordan                                Dave Moore           Roy Eltham

+    Hayaki Saito            Nathan Reed        Won Chun

+    Luke Graham             Johan Duparc       Nick Verigakis       the Horde3D community

+    Thomas Ruf              Ronny Chevalier                         github:rlyeh

+    Janez Zemva             John Bartholomew   Michal Cichon        github:romigrou

+    Jonathan Blow           Ken Hamada         Tero Hanninen        github:svdijk

+    Eugene Golushkov        Laurent Gomila     Cort Stratton        github:snagar

+    Aruelien Pocheville     Sergio Gonzalez    Thibault Reuille     github:Zelex

+    Cass Everitt            Ryamond Barbiero                        github:grim210

+    Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw

+    Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus

+    Josh Tobin                                 Matthew Gregan       github:poppolopoppo

+    Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji

+    Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007

+                            Brad Weinberger    Matvey Cherevko      github:mosra

+    Luca Sas                Alexander Veselov  Zack Middleton       [reserved]

+    Ryan C. Gordon          [reserved]                              [reserved]

+                     DO NOT ADD YOUR NAME HERE

+

+                     Jacko Dirks

+

+  To add your name to the credits, pick a random blank space in the middle and fill it.

+  80% of merge conflicts on stb PRs are due to people adding their name at the end

+  of the credits.

+*/

+

+#ifndef STBI_INCLUDE_STB_IMAGE_H

+#define STBI_INCLUDE_STB_IMAGE_H

+

+// DOCUMENTATION

+//

+// Limitations:

+//    - no 12-bit-per-channel JPEG

+//    - no JPEGs with arithmetic coding

+//    - GIF always returns *comp=4

+//

+// Basic usage (see HDR discussion below for HDR usage):

+//    int x,y,n;

+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);

+//    // ... process data if not NULL ...

+//    // ... x = width, y = height, n = # 8-bit components per pixel ...

+//    // ... replace '0' with '1'..'4' to force that many components per pixel

+//    // ... but 'n' will always be the number that it would have been if you said 0

+//    stbi_image_free(data)

+//

+// Standard parameters:

+//    int *x                 -- outputs image width in pixels

+//    int *y                 -- outputs image height in pixels

+//    int *channels_in_file  -- outputs # of image components in image file

+//    int desired_channels   -- if non-zero, # of image components requested in result

+//

+// The return value from an image loader is an 'unsigned char *' which points

+// to the pixel data, or NULL on an allocation failure or if the image is

+// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,

+// with each pixel consisting of N interleaved 8-bit components; the first

+// pixel pointed to is top-left-most in the image. There is no padding between

+// image scanlines or between pixels, regardless of format. The number of

+// components N is 'desired_channels' if desired_channels is non-zero, or

+// *channels_in_file otherwise. If desired_channels is non-zero,

+// *channels_in_file has the number of components that _would_ have been

+// output otherwise. E.g. if you set desired_channels to 4, you will always

+// get RGBA output, but you can check *channels_in_file to see if it's trivially

+// opaque because e.g. there were only 3 channels in the source image.

+//

+// An output image with N components has the following components interleaved

+// in this order in each pixel:

+//

+//     N=#comp     components

+//       1           grey

+//       2           grey, alpha

+//       3           red, green, blue

+//       4           red, green, blue, alpha

+//

+// If image loading fails for any reason, the return value will be NULL,

+// and *x, *y, *channels_in_file will be unchanged. The function

+// stbi_failure_reason() can be queried for an extremely brief, end-user

+// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS

+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly

+// more user-friendly ones.

+//

+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.

+//

+// To query the width, height and component count of an image without having to

+// decode the full file, you can use the stbi_info family of functions:

+//

+//   int x,y,n,ok;

+//   ok = stbi_info(filename, &x, &y, &n);

+//   // returns ok=1 and sets x, y, n if image is a supported format,

+//   // 0 otherwise.

+//

+// Note that stb_image pervasively uses ints in its public API for sizes,

+// including sizes of memory buffers. This is now part of the API and thus

+// hard to change without causing breakage. As a result, the various image

+// loaders all have certain limits on image size; these differ somewhat

+// by format but generally boil down to either just under 2GB or just under

+// 1GB. When the decoded image would be larger than this, stb_image decoding

+// will fail.

+//

+// Additionally, stb_image will reject image files that have any of their

+// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,

+// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,

+// the only way to have an image with such dimensions load correctly

+// is for it to have a rather extreme aspect ratio. Either way, the

+// assumption here is that such larger images are likely to be malformed

+// or malicious. If you do need to load an image with individual dimensions

+// larger than that, and it still fits in the overall size limit, you can

+// #define STBI_MAX_DIMENSIONS on your own to be something larger.

+//

+// ===========================================================================

+//

+// UNICODE:

+//

+//   If compiling for Windows and you wish to use Unicode filenames, compile

+//   with

+//       #define STBI_WINDOWS_UTF8

+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert

+//   Windows wchar_t filenames to utf8.

+//

+// ===========================================================================

+//

+// Philosophy

+//

+// stb libraries are designed with the following priorities:

+//

+//    1. easy to use

+//    2. easy to maintain

+//    3. good performance

+//

+// Sometimes I let "good performance" creep up in priority over "easy to maintain",

+// and for best performance I may provide less-easy-to-use APIs that give higher

+// performance, in addition to the easy-to-use ones. Nevertheless, it's important

+// to keep in mind that from the standpoint of you, a client of this library,

+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.

+//

+// Some secondary priorities arise directly from the first two, some of which

+// provide more explicit reasons why performance can't be emphasized.

+//

+//    - Portable ("ease of use")

+//    - Small source code footprint ("easy to maintain")

+//    - No dependencies ("ease of use")

+//

+// ===========================================================================

+//

+// I/O callbacks

+//

+// I/O callbacks allow you to read from arbitrary sources, like packaged

+// files or some other source. Data read from callbacks are processed

+// through a small internal buffer (currently 128 bytes) to try to reduce

+// overhead.

+//

+// The three functions you must define are "read" (reads some bytes of data),

+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).

+//

+// ===========================================================================

+//

+// SIMD support

+//

+// The JPEG decoder will try to automatically use SIMD kernels on x86 when

+// supported by the compiler. For ARM Neon support, you must explicitly

+// request it.

+//

+// (The old do-it-yourself SIMD API is no longer supported in the current

+// code.)

+//

+// On x86, SSE2 will automatically be used when available based on a run-time

+// test; if not, the generic C versions are used as a fall-back. On ARM targets,

+// the typical path is to have separate builds for NEON and non-NEON devices

+// (at least this is true for iOS and Android). Therefore, the NEON support is

+// toggled by a build flag: define STBI_NEON to get NEON loops.

+//

+// If for some reason you do not want to use any of SIMD code, or if

+// you have issues compiling it, you can disable it entirely by

+// defining STBI_NO_SIMD.

+//

+// ===========================================================================

+//

+// HDR image support   (disable by defining STBI_NO_HDR)

+//

+// stb_image supports loading HDR images in general, and currently the Radiance

+// .HDR file format specifically. You can still load any file through the existing

+// interface; if you attempt to load an HDR file, it will be automatically remapped

+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;

+// both of these constants can be reconfigured through this interface:

+//

+//     stbi_hdr_to_ldr_gamma(2.2f);

+//     stbi_hdr_to_ldr_scale(1.0f);

+//

+// (note, do not use _inverse_ constants; stbi_image will invert them

+// appropriately).

+//

+// Additionally, there is a new, parallel interface for loading files as

+// (linear) floats to preserve the full dynamic range:

+//

+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);

+//

+// If you load LDR images through this interface, those images will

+// be promoted to floating point values, run through the inverse of

+// constants corresponding to the above:

+//

+//     stbi_ldr_to_hdr_scale(1.0f);

+//     stbi_ldr_to_hdr_gamma(2.2f);

+//

+// Finally, given a filename (or an open file or memory block--see header

+// file for details) containing image data, you can query for the "most

+// appropriate" interface to use (that is, whether the image is HDR or

+// not), using:

+//

+//     stbi_is_hdr(char *filename);

+//

+// ===========================================================================

+//

+// iPhone PNG support:

+//

+// We optionally support converting iPhone-formatted PNGs (which store

+// premultiplied BGRA) back to RGB, even though they're internally encoded

+// differently. To enable this conversion, call

+// stbi_convert_iphone_png_to_rgb(1).

+//

+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per

+// pixel to remove any premultiplied alpha *only* if the image file explicitly

+// says there's premultiplied data (currently only happens in iPhone images,

+// and only if iPhone convert-to-rgb processing is on).

+//

+// ===========================================================================

+//

+// ADDITIONAL CONFIGURATION

+//

+//  - You can suppress implementation of any of the decoders to reduce

+//    your code footprint by #defining one or more of the following

+//    symbols before creating the implementation.

+//

+//        STBI_NO_JPEG

+//        STBI_NO_PNG

+//        STBI_NO_BMP

+//        STBI_NO_PSD

+//        STBI_NO_TGA

+//        STBI_NO_GIF

+//        STBI_NO_HDR

+//        STBI_NO_PIC

+//        STBI_NO_PNM   (.ppm and .pgm)

+//

+//  - You can request *only* certain decoders and suppress all other ones

+//    (this will be more forward-compatible, as addition of new decoders

+//    doesn't require you to disable them explicitly):

+//

+//        STBI_ONLY_JPEG

+//        STBI_ONLY_PNG

+//        STBI_ONLY_BMP

+//        STBI_ONLY_PSD

+//        STBI_ONLY_TGA

+//        STBI_ONLY_GIF

+//        STBI_ONLY_HDR

+//        STBI_ONLY_PIC

+//        STBI_ONLY_PNM   (.ppm and .pgm)

+//

+//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still

+//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB

+//

+//  - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater

+//    than that size (in either width or height) without further processing.

+//    This is to let programs in the wild set an upper bound to prevent

+//    denial-of-service attacks on untrusted data, as one could generate a

+//    valid image of gigantic dimensions and force stb_image to allocate a

+//    huge block of memory and spend disproportionate time decoding it. By

+//    default this is set to (1 << 24), which is 16777216, but that's still

+//    very big.

+

+#ifndef STBI_NO_STDIO

+#include <stdio.h>

+#endif // STBI_NO_STDIO

+

+#define STBI_VERSION 1

+

+enum

+{

+   STBI_default = 0, // only used for desired_channels

+

+   STBI_grey       = 1,

+   STBI_grey_alpha = 2,

+   STBI_rgb        = 3,

+   STBI_rgb_alpha  = 4

+};

+

+#include <stdlib.h>

+typedef unsigned char stbi_uc;

+typedef unsigned short stbi_us;

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#ifndef STBIDEF

+#ifdef STB_IMAGE_STATIC

+#define STBIDEF static

+#else

+#define STBIDEF extern

+#endif

+#endif

+

+//////////////////////////////////////////////////////////////////////////////

+//

+// PRIMARY API - works on images of any type

+//

+

+//

+// load image by filename, open file, or memory buffer

+//

+

+typedef struct

+{

+   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read

+   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative

+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data

+} stbi_io_callbacks;

+

+////////////////////////////////////

+//

+// 8-bits-per-channel interface

+//

+

+STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);

+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);

+

+#ifndef STBI_NO_STDIO

+STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);

+STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);

+// for stbi_load_from_file, file pointer is left pointing immediately after image

+#endif

+

+#ifndef STBI_NO_GIF

+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);

+#endif

+

+#ifdef STBI_WINDOWS_UTF8

+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);

+#endif

+

+////////////////////////////////////

+//

+// 16-bits-per-channel interface

+//

+

+STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);

+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);

+

+#ifndef STBI_NO_STDIO

+STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);

+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);

+#endif

+

+////////////////////////////////////

+//

+// float-per-channel interface

+//

+#ifndef STBI_NO_LINEAR

+   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);

+   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);

+

+   #ifndef STBI_NO_STDIO

+   STBIDEF float *stbi_loadf            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);

+   STBIDEF float *stbi_loadf_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);

+   #endif

+#endif

+

+#ifndef STBI_NO_HDR

+   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);

+   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);

+#endif // STBI_NO_HDR

+

+#ifndef STBI_NO_LINEAR

+   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);

+   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);

+#endif // STBI_NO_LINEAR

+

+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR

+STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);

+STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);

+#ifndef STBI_NO_STDIO

+STBIDEF int      stbi_is_hdr          (char const *filename);

+STBIDEF int      stbi_is_hdr_from_file(FILE *f);

+#endif // STBI_NO_STDIO

+

+

+// get a VERY brief reason for failure

+// on most compilers (and ALL modern mainstream compilers) this is threadsafe

+STBIDEF const char *stbi_failure_reason  (void);

+

+// free the loaded image -- this is just free()

+STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);

+

+// get image dimensions & components without fully decoding

+STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);

+STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);

+STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);

+STBIDEF int      stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);

+

+#ifndef STBI_NO_STDIO

+STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);

+STBIDEF int      stbi_info_from_file     (FILE *f,                  int *x, int *y, int *comp);

+STBIDEF int      stbi_is_16_bit          (char const *filename);

+STBIDEF int      stbi_is_16_bit_from_file(FILE *f);

+#endif

+

+

+

+// for image formats that explicitly notate that they have premultiplied alpha,

+// we just return the colors as stored in the file. set this flag to force

+// unpremultiplication. results are undefined if the unpremultiply overflow.

+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);

+

+// indicate whether we should process iphone images back to canonical format,

+// or just pass them through "as-is"

+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);

+

+// flip the image vertically, so the first pixel in the output array is the bottom left

+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);

+

+// as above, but only applies to images loaded on the thread that calls the function

+// this function is only available if your compiler supports thread-local variables;

+// calling it will fail to link if your compiler doesn't

+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);

+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);

+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);

+

+// ZLIB client - used by PNG, available for other purposes

+

+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);

+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);

+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);

+STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);

+

+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);

+STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);

+

+

+#ifdef __cplusplus

+}

+#endif

+

+//

+//

+////   end header file   /////////////////////////////////////////////////////

+#endif // STBI_INCLUDE_STB_IMAGE_H

+

+#ifdef STB_IMAGE_IMPLEMENTATION

+

+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \

+  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \

+  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \

+  || defined(STBI_ONLY_ZLIB)

+   #ifndef STBI_ONLY_JPEG

+   #define STBI_NO_JPEG

+   #endif

+   #ifndef STBI_ONLY_PNG

+   #define STBI_NO_PNG

+   #endif

+   #ifndef STBI_ONLY_BMP

+   #define STBI_NO_BMP

+   #endif

+   #ifndef STBI_ONLY_PSD

+   #define STBI_NO_PSD

+   #endif

+   #ifndef STBI_ONLY_TGA

+   #define STBI_NO_TGA

+   #endif

+   #ifndef STBI_ONLY_GIF

+   #define STBI_NO_GIF

+   #endif

+   #ifndef STBI_ONLY_HDR

+   #define STBI_NO_HDR

+   #endif

+   #ifndef STBI_ONLY_PIC

+   #define STBI_NO_PIC

+   #endif

+   #ifndef STBI_ONLY_PNM

+   #define STBI_NO_PNM

+   #endif

+#endif

+

+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)

+#define STBI_NO_ZLIB

+#endif

+

+

+#include <stdarg.h>

+#include <stddef.h> // ptrdiff_t on osx

+#include <stdlib.h>

+#include <string.h>

+#include <limits.h>

+

+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)

+#include <math.h>  // ldexp, pow

+#endif

+

+#ifndef STBI_NO_STDIO

+#include <stdio.h>

+#endif

+

+#ifndef STBI_ASSERT

+#include <assert.h>

+#define STBI_ASSERT(x) assert(x)

+#endif

+

+#ifdef __cplusplus

+#define STBI_EXTERN extern "C"

+#else

+#define STBI_EXTERN extern

+#endif

+

+

+#ifndef _MSC_VER

+   #ifdef __cplusplus

+   #define stbi_inline inline

+   #else

+   #define stbi_inline

+   #endif

+#else

+   #define stbi_inline __forceinline

+#endif

+

+#ifndef STBI_NO_THREAD_LOCALS

+   #if defined(__cplusplus) &&  __cplusplus >= 201103L

+      #define STBI_THREAD_LOCAL       thread_local

+   #elif defined(__GNUC__) && __GNUC__ < 5

+      #define STBI_THREAD_LOCAL       __thread

+   #elif defined(_MSC_VER)

+      #define STBI_THREAD_LOCAL       __declspec(thread)

+   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)

+      #define STBI_THREAD_LOCAL       _Thread_local

+   #endif

+

+   #ifndef STBI_THREAD_LOCAL

+      #if defined(__GNUC__)

+        #define STBI_THREAD_LOCAL       __thread

+      #endif

+   #endif

+#endif

+

+#ifdef _MSC_VER

+typedef unsigned short stbi__uint16;

+typedef   signed short stbi__int16;

+typedef unsigned int   stbi__uint32;

+typedef   signed int   stbi__int32;

+#else

+#include <stdint.h>

+typedef uint16_t stbi__uint16;

+typedef int16_t  stbi__int16;

+typedef uint32_t stbi__uint32;

+typedef int32_t  stbi__int32;

+#endif

+

+// should produce compiler error if size is wrong

+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];

+

+#ifdef _MSC_VER

+#define STBI_NOTUSED(v)  (void)(v)

+#else

+#define STBI_NOTUSED(v)  (void)sizeof(v)

+#endif

+

+#ifdef _MSC_VER

+#define STBI_HAS_LROTL

+#endif

+

+#ifdef STBI_HAS_LROTL

+   #define stbi_lrot(x,y)  _lrotl(x,y)

+#else

+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (-(y) & 31)))

+#endif

+

+#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))

+// ok

+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)

+// ok

+#else

+#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."

+#endif

+

+#ifndef STBI_MALLOC

+#define STBI_MALLOC(sz)           malloc(sz)

+#define STBI_REALLOC(p,newsz)     realloc(p,newsz)

+#define STBI_FREE(p)              free(p)

+#endif

+

+#ifndef STBI_REALLOC_SIZED

+#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)

+#endif

+

+// x86/x64 detection

+#if defined(__x86_64__) || defined(_M_X64)

+#define STBI__X64_TARGET

+#elif defined(__i386) || defined(_M_IX86)

+#define STBI__X86_TARGET

+#endif

+

+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)

+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,

+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,

+// but previous attempts to provide the SSE2 functions with runtime

+// detection caused numerous issues. The way architecture extensions are

+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.

+// New behavior: if compiled with -msse2, we use SSE2 without any

+// detection; if not, we don't use it at all.

+#define STBI_NO_SIMD

+#endif

+

+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)

+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET

+//

+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the

+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.

+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not

+// simultaneously enabling "-mstackrealign".

+//

+// See https://github.com/nothings/stb/issues/81 for more information.

+//

+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added

+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.

+#define STBI_NO_SIMD

+#endif

+

+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))

+#define STBI_SSE2

+#include <emmintrin.h>

+

+#ifdef _MSC_VER

+

+#if _MSC_VER >= 1400  // not VC6

+#include <intrin.h> // __cpuid

+static int stbi__cpuid3(void)

+{

+   int info[4];

+   __cpuid(info,1);

+   return info[3];

+}

+#else

+static int stbi__cpuid3(void)

+{

+   int res;

+   __asm {

+      mov  eax,1

+      cpuid

+      mov  res,edx

+   }

+   return res;

+}

+#endif

+

+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name

+

+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)

+static int stbi__sse2_available(void)

+{

+   int info3 = stbi__cpuid3();

+   return ((info3 >> 26) & 1) != 0;

+}

+#endif

+

+#else // assume GCC-style if not VC++

+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))

+

+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)

+static int stbi__sse2_available(void)

+{

+   // If we're even attempting to compile this on GCC/Clang, that means

+   // -msse2 is on, which means the compiler is allowed to use SSE2

+   // instructions at will, and so are we.

+   return 1;

+}

+#endif

+

+#endif

+#endif

+

+// ARM NEON

+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)

+#undef STBI_NEON

+#endif

+

+#ifdef STBI_NEON

+#include <arm_neon.h>

+#ifdef _MSC_VER

+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name

+#else

+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))

+#endif

+#endif

+

+#ifndef STBI_SIMD_ALIGN

+#define STBI_SIMD_ALIGN(type, name) type name

+#endif

+

+#ifndef STBI_MAX_DIMENSIONS

+#define STBI_MAX_DIMENSIONS (1 << 24)

+#endif

+

+///////////////////////////////////////////////

+//

+//  stbi__context struct and start_xxx functions

+

+// stbi__context structure is our basic context used by all images, so it

+// contains all the IO context, plus some basic image information

+typedef struct

+{

+   stbi__uint32 img_x, img_y;

+   int img_n, img_out_n;

+

+   stbi_io_callbacks io;

+   void *io_user_data;

+

+   int read_from_callbacks;

+   int buflen;

+   stbi_uc buffer_start[128];

+   int callback_already_read;

+

+   stbi_uc *img_buffer, *img_buffer_end;

+   stbi_uc *img_buffer_original, *img_buffer_original_end;

+} stbi__context;

+

+

+static void stbi__refill_buffer(stbi__context *s);

+

+// initialize a memory-decode context

+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)

+{

+   s->io.read = NULL;

+   s->read_from_callbacks = 0;

+   s->callback_already_read = 0;

+   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;

+   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;

+}

+

+// initialize a callback-based context

+static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)

+{

+   s->io = *c;

+   s->io_user_data = user;

+   s->buflen = sizeof(s->buffer_start);

+   s->read_from_callbacks = 1;

+   s->callback_already_read = 0;

+   s->img_buffer = s->img_buffer_original = s->buffer_start;

+   stbi__refill_buffer(s);

+   s->img_buffer_original_end = s->img_buffer_end;

+}

+

+#ifndef STBI_NO_STDIO

+

+static int stbi__stdio_read(void *user, char *data, int size)

+{

+   return (int) fread(data,1,size,(FILE*) user);

+}

+

+static void stbi__stdio_skip(void *user, int n)

+{

+   int ch;

+   fseek((FILE*) user, n, SEEK_CUR);

+   ch = fgetc((FILE*) user);  /* have to read a byte to reset feof()'s flag */

+   if (ch != EOF) {

+      ungetc(ch, (FILE *) user);  /* push byte back onto stream if valid. */

+   }

+}

+

+static int stbi__stdio_eof(void *user)

+{

+   return feof((FILE*) user) || ferror((FILE *) user);

+}

+

+static stbi_io_callbacks stbi__stdio_callbacks =

+{

+   stbi__stdio_read,

+   stbi__stdio_skip,

+   stbi__stdio_eof,

+};

+

+static void stbi__start_file(stbi__context *s, FILE *f)

+{

+   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);

+}

+

+//static void stop_file(stbi__context *s) { }

+

+#endif // !STBI_NO_STDIO

+

+static void stbi__rewind(stbi__context *s)

+{

+   // conceptually rewind SHOULD rewind to the beginning of the stream,

+   // but we just rewind to the beginning of the initial buffer, because

+   // we only use it after doing 'test', which only ever looks at at most 92 bytes

+   s->img_buffer = s->img_buffer_original;

+   s->img_buffer_end = s->img_buffer_original_end;

+}

+

+enum

+{

+   STBI_ORDER_RGB,

+   STBI_ORDER_BGR

+};

+

+typedef struct

+{

+   int bits_per_channel;

+   int num_channels;

+   int channel_order;

+} stbi__result_info;

+

+#ifndef STBI_NO_JPEG

+static int      stbi__jpeg_test(stbi__context *s);

+static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);

+#endif

+

+#ifndef STBI_NO_PNG

+static int      stbi__png_test(stbi__context *s);

+static void    *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);

+static int      stbi__png_is16(stbi__context *s);

+#endif

+

+#ifndef STBI_NO_BMP

+static int      stbi__bmp_test(stbi__context *s);

+static void    *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);

+#endif

+

+#ifndef STBI_NO_TGA

+static int      stbi__tga_test(stbi__context *s);

+static void    *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);

+#endif

+

+#ifndef STBI_NO_PSD

+static int      stbi__psd_test(stbi__context *s);

+static void    *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);

+static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);

+static int      stbi__psd_is16(stbi__context *s);

+#endif

+

+#ifndef STBI_NO_HDR

+static int      stbi__hdr_test(stbi__context *s);

+static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);

+#endif

+

+#ifndef STBI_NO_PIC

+static int      stbi__pic_test(stbi__context *s);

+static void    *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);

+#endif

+

+#ifndef STBI_NO_GIF

+static int      stbi__gif_test(stbi__context *s);

+static void    *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static void    *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);

+static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);

+#endif

+

+#ifndef STBI_NO_PNM

+static int      stbi__pnm_test(stbi__context *s);

+static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);

+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);

+static int      stbi__pnm_is16(stbi__context *s);

+#endif

+

+static

+#ifdef STBI_THREAD_LOCAL

+STBI_THREAD_LOCAL

+#endif

+const char *stbi__g_failure_reason;

+

+STBIDEF const char *stbi_failure_reason(void)

+{

+   return stbi__g_failure_reason;

+}

+

+#ifndef STBI_NO_FAILURE_STRINGS

+static int stbi__err(const char *str)

+{

+   stbi__g_failure_reason = str;

+   return 0;

+}

+#endif

+

+static void *stbi__malloc(size_t size)

+{

+    return STBI_MALLOC(size);

+}

+

+// stb_image uses ints pervasively, including for offset calculations.

+// therefore the largest decoded image size we can support with the

+// current code, even on 64-bit targets, is INT_MAX. this is not a

+// significant limitation for the intended use case.

+//

+// we do, however, need to make sure our size calculations don't

+// overflow. hence a few helper functions for size calculations that

+// multiply integers together, making sure that they're non-negative

+// and no overflow occurs.

+

+// return 1 if the sum is valid, 0 on overflow.

+// negative terms are considered invalid.

+static int stbi__addsizes_valid(int a, int b)

+{

+   if (b < 0) return 0;

+   // now 0 <= b <= INT_MAX, hence also

+   // 0 <= INT_MAX - b <= INTMAX.

+   // And "a + b <= INT_MAX" (which might overflow) is the

+   // same as a <= INT_MAX - b (no overflow)

+   return a <= INT_MAX - b;

+}

+

+// returns 1 if the product is valid, 0 on overflow.

+// negative factors are considered invalid.

+static int stbi__mul2sizes_valid(int a, int b)

+{

+   if (a < 0 || b < 0) return 0;

+   if (b == 0) return 1; // mul-by-0 is always safe

+   // portable way to check for no overflows in a*b

+   return a <= INT_MAX/b;

+}

+

+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)

+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow

+static int stbi__mad2sizes_valid(int a, int b, int add)

+{

+   return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);

+}

+#endif

+

+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow

+static int stbi__mad3sizes_valid(int a, int b, int c, int add)

+{

+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&

+      stbi__addsizes_valid(a*b*c, add);

+}

+

+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow

+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)

+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)

+{

+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&

+      stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);

+}

+#endif

+

+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)

+// mallocs with size overflow checking

+static void *stbi__malloc_mad2(int a, int b, int add)

+{

+   if (!stbi__mad2sizes_valid(a, b, add)) return NULL;

+   return stbi__malloc(a*b + add);

+}

+#endif

+

+static void *stbi__malloc_mad3(int a, int b, int c, int add)

+{

+   if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;

+   return stbi__malloc(a*b*c + add);

+}

+

+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)

+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)

+{

+   if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;

+   return stbi__malloc(a*b*c*d + add);

+}

+#endif

+

+// stbi__err - error

+// stbi__errpf - error returning pointer to float

+// stbi__errpuc - error returning pointer to unsigned char

+

+#ifdef STBI_NO_FAILURE_STRINGS

+   #define stbi__err(x,y)  0

+#elif defined(STBI_FAILURE_USERMSG)

+   #define stbi__err(x,y)  stbi__err(y)

+#else

+   #define stbi__err(x,y)  stbi__err(x)

+#endif

+

+#define stbi__errpf(x,y)   ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))

+#define stbi__errpuc(x,y)  ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))

+

+STBIDEF void stbi_image_free(void *retval_from_stbi_load)

+{

+   STBI_FREE(retval_from_stbi_load);

+}

+

+#ifndef STBI_NO_LINEAR

+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);

+#endif

+

+#ifndef STBI_NO_HDR

+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);

+#endif

+

+static int stbi__vertically_flip_on_load_global = 0;

+

+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)

+{

+   stbi__vertically_flip_on_load_global = flag_true_if_should_flip;

+}

+

+#ifndef STBI_THREAD_LOCAL

+#define stbi__vertically_flip_on_load  stbi__vertically_flip_on_load_global

+#else

+static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;

+

+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)

+{

+   stbi__vertically_flip_on_load_local = flag_true_if_should_flip;

+   stbi__vertically_flip_on_load_set = 1;

+}

+

+#define stbi__vertically_flip_on_load  (stbi__vertically_flip_on_load_set       \

+                                         ? stbi__vertically_flip_on_load_local  \

+                                         : stbi__vertically_flip_on_load_global)

+#endif // STBI_THREAD_LOCAL

+

+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)

+{

+   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields

+   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed

+   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order

+   ri->num_channels = 0;

+

+   // test the formats with a very explicit header first (at least a FOURCC

+   // or distinctive magic number first)

+   #ifndef STBI_NO_PNG

+   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);

+   #endif

+   #ifndef STBI_NO_BMP

+   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp, ri);

+   #endif

+   #ifndef STBI_NO_GIF

+   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp, ri);

+   #endif

+   #ifndef STBI_NO_PSD

+   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);

+   #else

+   STBI_NOTUSED(bpc);

+   #endif

+   #ifndef STBI_NO_PIC

+   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);

+   #endif

+

+   // then the formats that can end up attempting to load with just 1 or 2

+   // bytes matching expectations; these are prone to false positives, so

+   // try them later

+   #ifndef STBI_NO_JPEG

+   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);

+   #endif

+   #ifndef STBI_NO_PNM

+   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);

+   #endif

+

+   #ifndef STBI_NO_HDR

+   if (stbi__hdr_test(s)) {

+      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);

+      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);

+   }

+   #endif

+

+   #ifndef STBI_NO_TGA

+   // test tga last because it's a crappy test!

+   if (stbi__tga_test(s))

+      return stbi__tga_load(s,x,y,comp,req_comp, ri);

+   #endif

+

+   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");

+}

+

+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)

+{

+   int i;

+   int img_len = w * h * channels;

+   stbi_uc *reduced;

+

+   reduced = (stbi_uc *) stbi__malloc(img_len);

+   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");

+

+   for (i = 0; i < img_len; ++i)

+      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling

+

+   STBI_FREE(orig);

+   return reduced;

+}

+

+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)

+{

+   int i;

+   int img_len = w * h * channels;

+   stbi__uint16 *enlarged;

+

+   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);

+   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");

+

+   for (i = 0; i < img_len; ++i)

+      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff

+

+   STBI_FREE(orig);

+   return enlarged;

+}

+

+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)

+{

+   int row;

+   size_t bytes_per_row = (size_t)w * bytes_per_pixel;

+   stbi_uc temp[2048];

+   stbi_uc *bytes = (stbi_uc *)image;

+

+   for (row = 0; row < (h>>1); row++) {

+      stbi_uc *row0 = bytes + row*bytes_per_row;

+      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;

+      // swap row0 with row1

+      size_t bytes_left = bytes_per_row;

+      while (bytes_left) {

+         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);

+         memcpy(temp, row0, bytes_copy);

+         memcpy(row0, row1, bytes_copy);

+         memcpy(row1, temp, bytes_copy);

+         row0 += bytes_copy;

+         row1 += bytes_copy;

+         bytes_left -= bytes_copy;

+      }

+   }

+}

+

+#ifndef STBI_NO_GIF

+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)

+{

+   int slice;

+   int slice_size = w * h * bytes_per_pixel;

+

+   stbi_uc *bytes = (stbi_uc *)image;

+   for (slice = 0; slice < z; ++slice) {

+      stbi__vertical_flip(bytes, w, h, bytes_per_pixel);

+      bytes += slice_size;

+   }

+}

+#endif

+

+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__result_info ri;

+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);

+

+   if (result == NULL)

+      return NULL;

+

+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.

+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);

+

+   if (ri.bits_per_channel != 8) {

+      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);

+      ri.bits_per_channel = 8;

+   }

+

+   // @TODO: move stbi__convert_format to here

+

+   if (stbi__vertically_flip_on_load) {

+      int channels = req_comp ? req_comp : *comp;

+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));

+   }

+

+   return (unsigned char *) result;

+}

+

+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__result_info ri;

+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);

+

+   if (result == NULL)

+      return NULL;

+

+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.

+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);

+

+   if (ri.bits_per_channel != 16) {

+      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);

+      ri.bits_per_channel = 16;

+   }

+

+   // @TODO: move stbi__convert_format16 to here

+   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision

+

+   if (stbi__vertically_flip_on_load) {

+      int channels = req_comp ? req_comp : *comp;

+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));

+   }

+

+   return (stbi__uint16 *) result;

+}

+

+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)

+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)

+{

+   if (stbi__vertically_flip_on_load && result != NULL) {

+      int channels = req_comp ? req_comp : *comp;

+      stbi__vertical_flip(result, *x, *y, channels * sizeof(float));

+   }

+}

+#endif

+

+#ifndef STBI_NO_STDIO

+

+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)

+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);

+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);

+#endif

+

+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)

+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)

+{

+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);

+}

+#endif

+

+static FILE *stbi__fopen(char const *filename, char const *mode)

+{

+   FILE *f;

+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)

+   wchar_t wMode[64];

+   wchar_t wFilename[1024];

+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))

+      return 0;

+

+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))

+      return 0;

+

+#if defined(_MSC_VER) && _MSC_VER >= 1400

+	if (0 != _wfopen_s(&f, wFilename, wMode))

+		f = 0;

+#else

+   f = _wfopen(wFilename, wMode);

+#endif

+

+#elif defined(_MSC_VER) && _MSC_VER >= 1400

+   if (0 != fopen_s(&f, filename, mode))

+      f=0;

+#else

+   f = fopen(filename, mode);

+#endif

+   return f;

+}

+

+

+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)

+{

+   FILE *f = stbi__fopen(filename, "rb");

+   unsigned char *result;

+   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");

+   result = stbi_load_from_file(f,x,y,comp,req_comp);

+   fclose(f);

+   return result;

+}

+

+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)

+{

+   unsigned char *result;

+   stbi__context s;

+   stbi__start_file(&s,f);

+   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);

+   if (result) {

+      // need to 'unget' all the characters in the IO buffer

+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);

+   }

+   return result;

+}

+

+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__uint16 *result;

+   stbi__context s;

+   stbi__start_file(&s,f);

+   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);

+   if (result) {

+      // need to 'unget' all the characters in the IO buffer

+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);

+   }

+   return result;

+}

+

+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)

+{

+   FILE *f = stbi__fopen(filename, "rb");

+   stbi__uint16 *result;

+   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");

+   result = stbi_load_from_file_16(f,x,y,comp,req_comp);

+   fclose(f);

+   return result;

+}

+

+

+#endif //!STBI_NO_STDIO

+

+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)

+{

+   stbi__context s;

+   stbi__start_mem(&s,buffer,len);

+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);

+}

+

+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)

+{

+   stbi__context s;

+   stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);

+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);

+}

+

+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__context s;

+   stbi__start_mem(&s,buffer,len);

+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);

+}

+

+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__context s;

+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);

+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);

+}

+

+#ifndef STBI_NO_GIF

+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)

+{

+   unsigned char *result;

+   stbi__context s;

+   stbi__start_mem(&s,buffer,len);

+

+   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);

+   if (stbi__vertically_flip_on_load) {

+      stbi__vertical_flip_slices( result, *x, *y, *z, *comp );

+   }

+

+   return result;

+}

+#endif

+

+#ifndef STBI_NO_LINEAR

+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)

+{

+   unsigned char *data;

+   #ifndef STBI_NO_HDR

+   if (stbi__hdr_test(s)) {

+      stbi__result_info ri;

+      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);

+      if (hdr_data)

+         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);

+      return hdr_data;

+   }

+   #endif

+   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);

+   if (data)

+      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);

+   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");

+}

+

+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__context s;

+   stbi__start_mem(&s,buffer,len);

+   return stbi__loadf_main(&s,x,y,comp,req_comp);

+}

+

+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__context s;

+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);

+   return stbi__loadf_main(&s,x,y,comp,req_comp);

+}

+

+#ifndef STBI_NO_STDIO

+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)

+{

+   float *result;

+   FILE *f = stbi__fopen(filename, "rb");

+   if (!f) return stbi__errpf("can't fopen", "Unable to open file");

+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);

+   fclose(f);

+   return result;

+}

+

+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)

+{

+   stbi__context s;

+   stbi__start_file(&s,f);

+   return stbi__loadf_main(&s,x,y,comp,req_comp);

+}

+#endif // !STBI_NO_STDIO

+

+#endif // !STBI_NO_LINEAR

+

+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is

+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always

+// reports false!

+

+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)

+{

+   #ifndef STBI_NO_HDR

+   stbi__context s;

+   stbi__start_mem(&s,buffer,len);

+   return stbi__hdr_test(&s);

+   #else

+   STBI_NOTUSED(buffer);

+   STBI_NOTUSED(len);

+   return 0;

+   #endif

+}

+

+#ifndef STBI_NO_STDIO

+STBIDEF int      stbi_is_hdr          (char const *filename)

+{

+   FILE *f = stbi__fopen(filename, "rb");

+   int result=0;

+   if (f) {

+      result = stbi_is_hdr_from_file(f);

+      fclose(f);

+   }

+   return result;

+}

+

+STBIDEF int stbi_is_hdr_from_file(FILE *f)

+{

+   #ifndef STBI_NO_HDR

+   long pos = ftell(f);

+   int res;

+   stbi__context s;

+   stbi__start_file(&s,f);

+   res = stbi__hdr_test(&s);

+   fseek(f, pos, SEEK_SET);

+   return res;

+   #else

+   STBI_NOTUSED(f);

+   return 0;

+   #endif

+}

+#endif // !STBI_NO_STDIO

+

+STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)

+{

+   #ifndef STBI_NO_HDR

+   stbi__context s;

+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);

+   return stbi__hdr_test(&s);

+   #else

+   STBI_NOTUSED(clbk);

+   STBI_NOTUSED(user);

+   return 0;

+   #endif

+}

+

+#ifndef STBI_NO_LINEAR

+static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;

+

+STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }

+STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }

+#endif

+

+static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;

+

+STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }

+STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }

+

+

+//////////////////////////////////////////////////////////////////////////////

+//

+// Common code used by all image loaders

+//

+

+enum

+{

+   STBI__SCAN_load=0,

+   STBI__SCAN_type,

+   STBI__SCAN_header

+};

+

+static void stbi__refill_buffer(stbi__context *s)

+{

+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);

+   s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);

+   if (n == 0) {

+      // at end of file, treat same as if from memory, but need to handle case

+      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file

+      s->read_from_callbacks = 0;

+      s->img_buffer = s->buffer_start;

+      s->img_buffer_end = s->buffer_start+1;

+      *s->img_buffer = 0;

+   } else {

+      s->img_buffer = s->buffer_start;

+      s->img_buffer_end = s->buffer_start + n;

+   }

+}

+

+stbi_inline static stbi_uc stbi__get8(stbi__context *s)

+{

+   if (s->img_buffer < s->img_buffer_end)

+      return *s->img_buffer++;

+   if (s->read_from_callbacks) {

+      stbi__refill_buffer(s);

+      return *s->img_buffer++;

+   }

+   return 0;

+}

+

+#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)

+// nothing

+#else

+stbi_inline static int stbi__at_eof(stbi__context *s)

+{

+   if (s->io.read) {

+      if (!(s->io.eof)(s->io_user_data)) return 0;

+      // if feof() is true, check if buffer = end

+      // special case: we've only got the special 0 character at the end

+      if (s->read_from_callbacks == 0) return 1;

+   }

+

+   return s->img_buffer >= s->img_buffer_end;

+}

+#endif

+

+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)

+// nothing

+#else

+static void stbi__skip(stbi__context *s, int n)

+{

+   if (n == 0) return;  // already there!

+   if (n < 0) {

+      s->img_buffer = s->img_buffer_end;

+      return;

+   }

+   if (s->io.read) {

+      int blen = (int) (s->img_buffer_end - s->img_buffer);

+      if (blen < n) {

+         s->img_buffer = s->img_buffer_end;

+         (s->io.skip)(s->io_user_data, n - blen);

+         return;

+      }

+   }

+   s->img_buffer += n;

+}

+#endif

+

+#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)

+// nothing

+#else

+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)

+{

+   if (s->io.read) {

+      int blen = (int) (s->img_buffer_end - s->img_buffer);

+      if (blen < n) {

+         int res, count;

+

+         memcpy(buffer, s->img_buffer, blen);

+

+         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);

+         res = (count == (n-blen));

+         s->img_buffer = s->img_buffer_end;

+         return res;

+      }

+   }

+

+   if (s->img_buffer+n <= s->img_buffer_end) {

+      memcpy(buffer, s->img_buffer, n);

+      s->img_buffer += n;

+      return 1;

+   } else

+      return 0;

+}

+#endif

+

+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)

+// nothing

+#else

+static int stbi__get16be(stbi__context *s)

+{

+   int z = stbi__get8(s);

+   return (z << 8) + stbi__get8(s);

+}

+#endif

+

+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)

+// nothing

+#else

+static stbi__uint32 stbi__get32be(stbi__context *s)

+{

+   stbi__uint32 z = stbi__get16be(s);

+   return (z << 16) + stbi__get16be(s);

+}

+#endif

+

+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)

+// nothing

+#else

+static int stbi__get16le(stbi__context *s)

+{

+   int z = stbi__get8(s);

+   return z + (stbi__get8(s) << 8);

+}

+#endif

+

+#ifndef STBI_NO_BMP

+static stbi__uint32 stbi__get32le(stbi__context *s)

+{

+   stbi__uint32 z = stbi__get16le(s);

+   z += (stbi__uint32)stbi__get16le(s) << 16;

+   return z;

+}

+#endif

+

+#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings

+

+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)

+// nothing

+#else

+//////////////////////////////////////////////////////////////////////////////

+//

+//  generic converter from built-in img_n to req_comp

+//    individual types do this automatically as much as possible (e.g. jpeg

+//    does all cases internally since it needs to colorspace convert anyway,

+//    and it never has alpha, so very few cases ). png can automatically

+//    interleave an alpha=255 channel, but falls back to this for other cases

+//

+//  assume data buffer is malloced, so malloc a new one and free that one

+//  only failure mode is malloc failing

+

+static stbi_uc stbi__compute_y(int r, int g, int b)

+{

+   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);

+}

+#endif

+

+#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)

+// nothing

+#else

+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)

+{

+   int i,j;

+   unsigned char *good;

+

+   if (req_comp == img_n) return data;

+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);

+

+   good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);

+   if (good == NULL) {

+      STBI_FREE(data);

+      return stbi__errpuc("outofmem", "Out of memory");

+   }

+

+   for (j=0; j < (int) y; ++j) {

+      unsigned char *src  = data + j * x * img_n   ;

+      unsigned char *dest = good + j * x * req_comp;

+

+      #define STBI__COMBO(a,b)  ((a)*8+(b))

+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)

+      // convert source image with img_n components to one with req_comp components;

+      // avoid switch per pixel, so use switch per scanline and massive macros

+      switch (STBI__COMBO(img_n, req_comp)) {

+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;

+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;

+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;                     } break;

+         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;

+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;

+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                  } break;

+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255;        } break;

+         STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;

+         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255;    } break;

+         STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;

+         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;

+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                    } break;

+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");

+      }

+      #undef STBI__CASE

+   }

+

+   STBI_FREE(data);

+   return good;

+}

+#endif

+

+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)

+// nothing

+#else

+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)

+{

+   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);

+}

+#endif

+

+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)

+// nothing

+#else

+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)

+{

+   int i,j;

+   stbi__uint16 *good;

+

+   if (req_comp == img_n) return data;

+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);

+

+   good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);

+   if (good == NULL) {

+      STBI_FREE(data);

+      return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");

+   }

+

+   for (j=0; j < (int) y; ++j) {

+      stbi__uint16 *src  = data + j * x * img_n   ;

+      stbi__uint16 *dest = good + j * x * req_comp;

+

+      #define STBI__COMBO(a,b)  ((a)*8+(b))

+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)

+      // convert source image with img_n components to one with req_comp components;

+      // avoid switch per pixel, so use switch per scanline and massive macros

+      switch (STBI__COMBO(img_n, req_comp)) {

+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;

+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;

+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;                     } break;

+         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;

+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;

+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                     } break;

+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff;        } break;

+         STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;

+         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;

+         STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;

+         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;

+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                       } break;

+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");

+      }

+      #undef STBI__CASE

+   }

+

+   STBI_FREE(data);

+   return good;

+}

+#endif

+

+#ifndef STBI_NO_LINEAR

+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)

+{

+   int i,k,n;

+   float *output;

+   if (!data) return NULL;

+   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);

+   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }

+   // compute number of non-alpha components

+   if (comp & 1) n = comp; else n = comp-1;

+   for (i=0; i < x*y; ++i) {

+      for (k=0; k < n; ++k) {

+         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);

+      }

+   }

+   if (n < comp) {

+      for (i=0; i < x*y; ++i) {

+         output[i*comp + n] = data[i*comp + n]/255.0f;

+      }

+   }

+   STBI_FREE(data);

+   return output;

+}

+#endif

+

+#ifndef STBI_NO_HDR

+#define stbi__float2int(x)   ((int) (x))

+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)

+{

+   int i,k,n;

+   stbi_uc *output;

+   if (!data) return NULL;

+   output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);

+   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }

+   // compute number of non-alpha components

+   if (comp & 1) n = comp; else n = comp-1;

+   for (i=0; i < x*y; ++i) {

+      for (k=0; k < n; ++k) {

+         float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;

+         if (z < 0) z = 0;

+         if (z > 255) z = 255;

+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);

+      }

+      if (k < comp) {

+         float z = data[i*comp+k] * 255 + 0.5f;

+         if (z < 0) z = 0;

+         if (z > 255) z = 255;

+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);

+      }

+   }

+   STBI_FREE(data);

+   return output;

+}

+#endif

+

+//////////////////////////////////////////////////////////////////////////////

+//

+//  "baseline" JPEG/JFIF decoder

+//

+//    simple implementation

+//      - doesn't support delayed output of y-dimension

+//      - simple interface (only one output format: 8-bit interleaved RGB)

+//      - doesn't try to recover corrupt jpegs

+//      - doesn't allow partial loading, loading multiple at once

+//      - still fast on x86 (copying globals into locals doesn't help x86)

+//      - allocates lots of intermediate memory (full size of all components)

+//        - non-interleaved case requires this anyway

+//        - allows good upsampling (see next)

+//    high-quality

+//      - upsampled channels are bilinearly interpolated, even across blocks

+//      - quality integer IDCT derived from IJG's 'slow'

+//    performance

+//      - fast huffman; reasonable integer IDCT

+//      - some SIMD kernels for common paths on targets with SSE2/NEON

+//      - uses a lot of intermediate memory, could cache poorly

+

+#ifndef STBI_NO_JPEG

+

+// huffman decoding acceleration

+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache

+

+typedef struct

+{

+   stbi_uc  fast[1 << FAST_BITS];

+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win

+   stbi__uint16 code[256];

+   stbi_uc  values[256];

+   stbi_uc  size[257];

+   unsigned int maxcode[18];

+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'

+} stbi__huffman;

+

+typedef struct

+{

+   stbi__context *s;

+   stbi__huffman huff_dc[4];

+   stbi__huffman huff_ac[4];

+   stbi__uint16 dequant[4][64];

+   stbi__int16 fast_ac[4][1 << FAST_BITS];

+

+// sizes for components, interleaved MCUs

+   int img_h_max, img_v_max;

+   int img_mcu_x, img_mcu_y;

+   int img_mcu_w, img_mcu_h;

+

+// definition of jpeg image component

+   struct

+   {

+      int id;

+      int h,v;

+      int tq;

+      int hd,ha;

+      int dc_pred;

+

+      int x,y,w2,h2;

+      stbi_uc *data;

+      void *raw_data, *raw_coeff;

+      stbi_uc *linebuf;

+      short   *coeff;   // progressive only

+      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks

+   } img_comp[4];

+

+   stbi__uint32   code_buffer; // jpeg entropy-coded buffer

+   int            code_bits;   // number of valid bits

+   unsigned char  marker;      // marker seen while filling entropy buffer

+   int            nomore;      // flag if we saw a marker so must stop

+

+   int            progressive;

+   int            spec_start;

+   int            spec_end;

+   int            succ_high;

+   int            succ_low;

+   int            eob_run;

+   int            jfif;

+   int            app14_color_transform; // Adobe APP14 tag

+   int            rgb;

+

+   int scan_n, order[4];

+   int restart_interval, todo;

+

+// kernels

+   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);

+   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);

+   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);

+} stbi__jpeg;

+

+static int stbi__build_huffman(stbi__huffman *h, int *count)

+{

+   int i,j,k=0;

+   unsigned int code;

+   // build size list for each symbol (from JPEG spec)

+   for (i=0; i < 16; ++i)

+      for (j=0; j < count[i]; ++j)

+         h->size[k++] = (stbi_uc) (i+1);

+   h->size[k] = 0;

+

+   // compute actual symbols (from jpeg spec)

+   code = 0;

+   k = 0;

+   for(j=1; j <= 16; ++j) {

+      // compute delta to add to code to compute symbol id

+      h->delta[j] = k - code;

+      if (h->size[k] == j) {

+         while (h->size[k] == j)

+            h->code[k++] = (stbi__uint16) (code++);

+         if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");

+      }

+      // compute largest code + 1 for this size, preshifted as needed later

+      h->maxcode[j] = code << (16-j);

+      code <<= 1;

+   }

+   h->maxcode[j] = 0xffffffff;

+

+   // build non-spec acceleration table; 255 is flag for not-accelerated

+   memset(h->fast, 255, 1 << FAST_BITS);

+   for (i=0; i < k; ++i) {

+      int s = h->size[i];

+      if (s <= FAST_BITS) {

+         int c = h->code[i] << (FAST_BITS-s);

+         int m = 1 << (FAST_BITS-s);

+         for (j=0; j < m; ++j) {

+            h->fast[c+j] = (stbi_uc) i;

+         }

+      }

+   }

+   return 1;

+}

+

+// build a table that decodes both magnitude and value of small ACs in

+// one go.

+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)

+{

+   int i;

+   for (i=0; i < (1 << FAST_BITS); ++i) {

+      stbi_uc fast = h->fast[i];

+      fast_ac[i] = 0;

+      if (fast < 255) {

+         int rs = h->values[fast];

+         int run = (rs >> 4) & 15;

+         int magbits = rs & 15;

+         int len = h->size[fast];

+

+         if (magbits && len + magbits <= FAST_BITS) {

+            // magnitude code followed by receive_extend code

+            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);

+            int m = 1 << (magbits - 1);

+            if (k < m) k += (~0U << magbits) + 1;

+            // if the result is small enough, we can fit it in fast_ac table

+            if (k >= -128 && k <= 127)

+               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));

+         }

+      }

+   }

+}

+

+static void stbi__grow_buffer_unsafe(stbi__jpeg *j)

+{

+   do {

+      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);

+      if (b == 0xff) {

+         int c = stbi__get8(j->s);

+         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes

+         if (c != 0) {

+            j->marker = (unsigned char) c;

+            j->nomore = 1;

+            return;

+         }

+      }

+      j->code_buffer |= b << (24 - j->code_bits);

+      j->code_bits += 8;

+   } while (j->code_bits <= 24);

+}

+

+// (1 << n) - 1

+static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};

+

+// decode a jpeg huffman value from the bitstream

+stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)

+{

+   unsigned int temp;

+   int c,k;

+

+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);

+

+   // look at the top FAST_BITS and determine what symbol ID it is,

+   // if the code is <= FAST_BITS

+   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);

+   k = h->fast[c];

+   if (k < 255) {

+      int s = h->size[k];

+      if (s > j->code_bits)

+         return -1;

+      j->code_buffer <<= s;

+      j->code_bits -= s;

+      return h->values[k];

+   }

+

+   // naive test is to shift the code_buffer down so k bits are

+   // valid, then test against maxcode. To speed this up, we've

+   // preshifted maxcode left so that it has (16-k) 0s at the

+   // end; in other words, regardless of the number of bits, it

+   // wants to be compared against something shifted to have 16;

+   // that way we don't need to shift inside the loop.

+   temp = j->code_buffer >> 16;

+   for (k=FAST_BITS+1 ; ; ++k)

+      if (temp < h->maxcode[k])

+         break;

+   if (k == 17) {

+      // error! code not found

+      j->code_bits -= 16;

+      return -1;

+   }

+

+   if (k > j->code_bits)

+      return -1;

+

+   // convert the huffman code to the symbol id

+   c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];

+   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);

+

+   // convert the id to a symbol

+   j->code_bits -= k;

+   j->code_buffer <<= k;

+   return h->values[c];

+}

+

+// bias[n] = (-1<<n) + 1

+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};

+

+// combined JPEG 'receive' and JPEG 'extend', since baseline

+// always extends everything it receives.

+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)

+{

+   unsigned int k;

+   int sgn;

+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);

+

+   sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)

+   k = stbi_lrot(j->code_buffer, n);

+   j->code_buffer = k & ~stbi__bmask[n];

+   k &= stbi__bmask[n];

+   j->code_bits -= n;

+   return k + (stbi__jbias[n] & (sgn - 1));

+}

+

+// get some unsigned bits

+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)

+{

+   unsigned int k;

+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);

+   k = stbi_lrot(j->code_buffer, n);

+   j->code_buffer = k & ~stbi__bmask[n];

+   k &= stbi__bmask[n];

+   j->code_bits -= n;

+   return k;

+}

+

+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)

+{

+   unsigned int k;

+   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);

+   k = j->code_buffer;

+   j->code_buffer <<= 1;

+   --j->code_bits;

+   return k & 0x80000000;

+}

+

+// given a value that's at position X in the zigzag stream,

+// where does it appear in the 8x8 matrix coded as row-major?

+static const stbi_uc stbi__jpeg_dezigzag[64+15] =

+{

+    0,  1,  8, 16,  9,  2,  3, 10,

+   17, 24, 32, 25, 18, 11,  4,  5,

+   12, 19, 26, 33, 40, 48, 41, 34,

+   27, 20, 13,  6,  7, 14, 21, 28,

+   35, 42, 49, 56, 57, 50, 43, 36,

+   29, 22, 15, 23, 30, 37, 44, 51,

+   58, 59, 52, 45, 38, 31, 39, 46,

+   53, 60, 61, 54, 47, 55, 62, 63,

+   // let corrupt input sample past end

+   63, 63, 63, 63, 63, 63, 63, 63,

+   63, 63, 63, 63, 63, 63, 63

+};

+

+// decode one 64-entry block--

+static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)

+{

+   int diff,dc,k;

+   int t;

+

+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);

+   t = stbi__jpeg_huff_decode(j, hdc);

+   if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");

+

+   // 0 all the ac values now so we can do it 32-bits at a time

+   memset(data,0,64*sizeof(data[0]));

+

+   diff = t ? stbi__extend_receive(j, t) : 0;

+   dc = j->img_comp[b].dc_pred + diff;

+   j->img_comp[b].dc_pred = dc;

+   data[0] = (short) (dc * dequant[0]);

+

+   // decode AC components, see JPEG spec

+   k = 1;

+   do {

+      unsigned int zig;

+      int c,r,s;

+      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);

+      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);

+      r = fac[c];

+      if (r) { // fast-AC path

+         k += (r >> 4) & 15; // run

+         s = r & 15; // combined length

+         j->code_buffer <<= s;

+         j->code_bits -= s;

+         // decode into unzigzag'd location

+         zig = stbi__jpeg_dezigzag[k++];

+         data[zig] = (short) ((r >> 8) * dequant[zig]);

+      } else {

+         int rs = stbi__jpeg_huff_decode(j, hac);

+         if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");

+         s = rs & 15;

+         r = rs >> 4;

+         if (s == 0) {

+            if (rs != 0xf0) break; // end block

+            k += 16;

+         } else {

+            k += r;

+            // decode into unzigzag'd location

+            zig = stbi__jpeg_dezigzag[k++];

+            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);

+         }

+      }

+   } while (k < 64);

+   return 1;

+}

+

+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)

+{

+   int diff,dc;

+   int t;

+   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");

+

+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);

+

+   if (j->succ_high == 0) {

+      // first scan for DC coefficient, must be first

+      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now

+      t = stbi__jpeg_huff_decode(j, hdc);

+      if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");

+      diff = t ? stbi__extend_receive(j, t) : 0;

+

+      dc = j->img_comp[b].dc_pred + diff;

+      j->img_comp[b].dc_pred = dc;

+      data[0] = (short) (dc * (1 << j->succ_low));

+   } else {

+      // refinement scan for DC coefficient

+      if (stbi__jpeg_get_bit(j))

+         data[0] += (short) (1 << j->succ_low);

+   }

+   return 1;

+}

+

+// @OPTIMIZE: store non-zigzagged during the decode passes,

+// and only de-zigzag when dequantizing

+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)

+{

+   int k;

+   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");

+

+   if (j->succ_high == 0) {

+      int shift = j->succ_low;

+

+      if (j->eob_run) {

+         --j->eob_run;

+         return 1;

+      }

+

+      k = j->spec_start;

+      do {

+         unsigned int zig;

+         int c,r,s;

+         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);

+         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);

+         r = fac[c];

+         if (r) { // fast-AC path

+            k += (r >> 4) & 15; // run

+            s = r & 15; // combined length

+            j->code_buffer <<= s;

+            j->code_bits -= s;

+            zig = stbi__jpeg_dezigzag[k++];

+            data[zig] = (short) ((r >> 8) * (1 << shift));

+         } else {

+            int rs = stbi__jpeg_huff_decode(j, hac);

+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");

+            s = rs & 15;

+            r = rs >> 4;

+            if (s == 0) {

+               if (r < 15) {

+                  j->eob_run = (1 << r);

+                  if (r)

+                     j->eob_run += stbi__jpeg_get_bits(j, r);

+                  --j->eob_run;

+                  break;

+               }

+               k += 16;

+            } else {

+               k += r;

+               zig = stbi__jpeg_dezigzag[k++];

+               data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));

+            }

+         }

+      } while (k <= j->spec_end);

+   } else {

+      // refinement scan for these AC coefficients

+

+      short bit = (short) (1 << j->succ_low);

+

+      if (j->eob_run) {

+         --j->eob_run;

+         for (k = j->spec_start; k <= j->spec_end; ++k) {

+            short *p = &data[stbi__jpeg_dezigzag[k]];

+            if (*p != 0)

+               if (stbi__jpeg_get_bit(j))

+                  if ((*p & bit)==0) {

+                     if (*p > 0)

+                        *p += bit;

+                     else

+                        *p -= bit;

+                  }

+         }

+      } else {

+         k = j->spec_start;

+         do {

+            int r,s;

+            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh

+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");

+            s = rs & 15;

+            r = rs >> 4;

+            if (s == 0) {

+               if (r < 15) {

+                  j->eob_run = (1 << r) - 1;

+                  if (r)

+                     j->eob_run += stbi__jpeg_get_bits(j, r);

+                  r = 64; // force end of block

+               } else {

+                  // r=15 s=0 should write 16 0s, so we just do

+                  // a run of 15 0s and then write s (which is 0),

+                  // so we don't have to do anything special here

+               }

+            } else {

+               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");

+               // sign bit

+               if (stbi__jpeg_get_bit(j))

+                  s = bit;

+               else

+                  s = -bit;

+            }

+

+            // advance by r

+            while (k <= j->spec_end) {

+               short *p = &data[stbi__jpeg_dezigzag[k++]];

+               if (*p != 0) {

+                  if (stbi__jpeg_get_bit(j))

+                     if ((*p & bit)==0) {

+                        if (*p > 0)

+                           *p += bit;

+                        else

+                           *p -= bit;

+                     }

+               } else {

+                  if (r == 0) {

+                     *p = (short) s;

+                     break;

+                  }

+                  --r;

+               }

+            }

+         } while (k <= j->spec_end);

+      }

+   }

+   return 1;

+}

+

+// take a -128..127 value and stbi__clamp it and convert to 0..255

+stbi_inline static stbi_uc stbi__clamp(int x)

+{

+   // trick to use a single test to catch both cases

+   if ((unsigned int) x > 255) {

+      if (x < 0) return 0;

+      if (x > 255) return 255;

+   }

+   return (stbi_uc) x;

+}

+

+#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))

+#define stbi__fsh(x)  ((x) * 4096)

+

+// derived from jidctint -- DCT_ISLOW

+#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \

+   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \

+   p2 = s2;                                    \

+   p3 = s6;                                    \

+   p1 = (p2+p3) * stbi__f2f(0.5411961f);       \

+   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \

+   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \

+   p2 = s0;                                    \

+   p3 = s4;                                    \

+   t0 = stbi__fsh(p2+p3);                      \

+   t1 = stbi__fsh(p2-p3);                      \

+   x0 = t0+t3;                                 \

+   x3 = t0-t3;                                 \

+   x1 = t1+t2;                                 \

+   x2 = t1-t2;                                 \

+   t0 = s7;                                    \

+   t1 = s5;                                    \

+   t2 = s3;                                    \

+   t3 = s1;                                    \

+   p3 = t0+t2;                                 \

+   p4 = t1+t3;                                 \

+   p1 = t0+t3;                                 \

+   p2 = t1+t2;                                 \

+   p5 = (p3+p4)*stbi__f2f( 1.175875602f);      \

+   t0 = t0*stbi__f2f( 0.298631336f);           \

+   t1 = t1*stbi__f2f( 2.053119869f);           \

+   t2 = t2*stbi__f2f( 3.072711026f);           \

+   t3 = t3*stbi__f2f( 1.501321110f);           \

+   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \

+   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \

+   p3 = p3*stbi__f2f(-1.961570560f);           \

+   p4 = p4*stbi__f2f(-0.390180644f);           \

+   t3 += p1+p4;                                \

+   t2 += p2+p3;                                \

+   t1 += p2+p4;                                \

+   t0 += p1+p3;

+

+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])

+{

+   int i,val[64],*v=val;

+   stbi_uc *o;

+   short *d = data;

+

+   // columns

+   for (i=0; i < 8; ++i,++d, ++v) {

+      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing

+      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0

+           && d[40]==0 && d[48]==0 && d[56]==0) {

+         //    no shortcut                 0     seconds

+         //    (1|2|3|4|5|6|7)==0          0     seconds

+         //    all separate               -0.047 seconds

+         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds

+         int dcterm = d[0]*4;

+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;

+      } else {

+         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])

+         // constants scaled things up by 1<<12; let's bring them back

+         // down, but keep 2 extra bits of precision

+         x0 += 512; x1 += 512; x2 += 512; x3 += 512;

+         v[ 0] = (x0+t3) >> 10;

+         v[56] = (x0-t3) >> 10;

+         v[ 8] = (x1+t2) >> 10;

+         v[48] = (x1-t2) >> 10;

+         v[16] = (x2+t1) >> 10;

+         v[40] = (x2-t1) >> 10;

+         v[24] = (x3+t0) >> 10;

+         v[32] = (x3-t0) >> 10;

+      }

+   }

+

+   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {

+      // no fast case since the first 1D IDCT spread components out

+      STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])

+      // constants scaled things up by 1<<12, plus we had 1<<2 from first

+      // loop, plus horizontal and vertical each scale by sqrt(8) so together

+      // we've got an extra 1<<3, so 1<<17 total we need to remove.

+      // so we want to round that, which means adding 0.5 * 1<<17,

+      // aka 65536. Also, we'll end up with -128 to 127 that we want

+      // to encode as 0..255 by adding 128, so we'll add that before the shift

+      x0 += 65536 + (128<<17);

+      x1 += 65536 + (128<<17);

+      x2 += 65536 + (128<<17);

+      x3 += 65536 + (128<<17);

+      // tried computing the shifts into temps, or'ing the temps to see

+      // if any were out of range, but that was slower

+      o[0] = stbi__clamp((x0+t3) >> 17);

+      o[7] = stbi__clamp((x0-t3) >> 17);

+      o[1] = stbi__clamp((x1+t2) >> 17);

+      o[6] = stbi__clamp((x1-t2) >> 17);

+      o[2] = stbi__clamp((x2+t1) >> 17);

+      o[5] = stbi__clamp((x2-t1) >> 17);

+      o[3] = stbi__clamp((x3+t0) >> 17);

+      o[4] = stbi__clamp((x3-t0) >> 17);

+   }

+}

+

+#ifdef STBI_SSE2

+// sse2 integer IDCT. not the fastest possible implementation but it

+// produces bit-identical results to the generic C version so it's

+// fully "transparent".

+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])

+{

+   // This is constructed to match our regular (generic) integer IDCT exactly.

+   __m128i row0, row1, row2, row3, row4, row5, row6, row7;

+   __m128i tmp;

+

+   // dot product constant: even elems=x, odd elems=y

+   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))

+

+   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)

+   // out(1) = c1[even]*x + c1[odd]*y

+   #define dct_rot(out0,out1, x,y,c0,c1) \

+      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \

+      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \

+      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \

+      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \

+      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \

+      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)

+

+   // out = in << 12  (in 16-bit, out 32-bit)

+   #define dct_widen(out, in) \

+      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \

+      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)

+

+   // wide add

+   #define dct_wadd(out, a, b) \

+      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \

+      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)

+

+   // wide sub

+   #define dct_wsub(out, a, b) \

+      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \

+      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)

+

+   // butterfly a/b, add bias, then shift by "s" and pack

+   #define dct_bfly32o(out0, out1, a,b,bias,s) \

+      { \

+         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \

+         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \

+         dct_wadd(sum, abiased, b); \

+         dct_wsub(dif, abiased, b); \

+         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \

+         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \

+      }

+

+   // 8-bit interleave step (for transposes)

+   #define dct_interleave8(a, b) \

+      tmp = a; \

+      a = _mm_unpacklo_epi8(a, b); \

+      b = _mm_unpackhi_epi8(tmp, b)

+

+   // 16-bit interleave step (for transposes)

+   #define dct_interleave16(a, b) \

+      tmp = a; \

+      a = _mm_unpacklo_epi16(a, b); \

+      b = _mm_unpackhi_epi16(tmp, b)

+

+   #define dct_pass(bias,shift) \

+      { \

+         /* even part */ \

+         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \

+         __m128i sum04 = _mm_add_epi16(row0, row4); \

+         __m128i dif04 = _mm_sub_epi16(row0, row4); \

+         dct_widen(t0e, sum04); \

+         dct_widen(t1e, dif04); \

+         dct_wadd(x0, t0e, t3e); \

+         dct_wsub(x3, t0e, t3e); \

+         dct_wadd(x1, t1e, t2e); \

+         dct_wsub(x2, t1e, t2e); \

+         /* odd part */ \

+         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \

+         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \

+         __m128i sum17 = _mm_add_epi16(row1, row7); \

+         __m128i sum35 = _mm_add_epi16(row3, row5); \

+         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \

+         dct_wadd(x4, y0o, y4o); \

+         dct_wadd(x5, y1o, y5o); \

+         dct_wadd(x6, y2o, y5o); \

+         dct_wadd(x7, y3o, y4o); \

+         dct_bfly32o(row0,row7, x0,x7,bias,shift); \

+         dct_bfly32o(row1,row6, x1,x6,bias,shift); \

+         dct_bfly32o(row2,row5, x2,x5,bias,shift); \

+         dct_bfly32o(row3,row4, x3,x4,bias,shift); \

+      }

+

+   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));

+   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));

+   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));

+   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));

+   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));

+   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));

+   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));

+   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));

+

+   // rounding biases in column/row passes, see stbi__idct_block for explanation.

+   __m128i bias_0 = _mm_set1_epi32(512);

+   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));

+

+   // load

+   row0 = _mm_load_si128((const __m128i *) (data + 0*8));

+   row1 = _mm_load_si128((const __m128i *) (data + 1*8));

+   row2 = _mm_load_si128((const __m128i *) (data + 2*8));

+   row3 = _mm_load_si128((const __m128i *) (data + 3*8));

+   row4 = _mm_load_si128((const __m128i *) (data + 4*8));

+   row5 = _mm_load_si128((const __m128i *) (data + 5*8));

+   row6 = _mm_load_si128((const __m128i *) (data + 6*8));

+   row7 = _mm_load_si128((const __m128i *) (data + 7*8));

+

+   // column pass

+   dct_pass(bias_0, 10);

+

+   {

+      // 16bit 8x8 transpose pass 1

+      dct_interleave16(row0, row4);

+      dct_interleave16(row1, row5);

+      dct_interleave16(row2, row6);

+      dct_interleave16(row3, row7);

+

+      // transpose pass 2

+      dct_interleave16(row0, row2);

+      dct_interleave16(row1, row3);

+      dct_interleave16(row4, row6);

+      dct_interleave16(row5, row7);

+

+      // transpose pass 3

+      dct_interleave16(row0, row1);

+      dct_interleave16(row2, row3);

+      dct_interleave16(row4, row5);

+      dct_interleave16(row6, row7);

+   }

+

+   // row pass

+   dct_pass(bias_1, 17);

+

+   {

+      // pack

+      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7

+      __m128i p1 = _mm_packus_epi16(row2, row3);

+      __m128i p2 = _mm_packus_epi16(row4, row5);

+      __m128i p3 = _mm_packus_epi16(row6, row7);

+

+      // 8bit 8x8 transpose pass 1

+      dct_interleave8(p0, p2); // a0e0a1e1...

+      dct_interleave8(p1, p3); // c0g0c1g1...

+

+      // transpose pass 2

+      dct_interleave8(p0, p1); // a0c0e0g0...

+      dct_interleave8(p2, p3); // b0d0f0h0...

+

+      // transpose pass 3

+      dct_interleave8(p0, p2); // a0b0c0d0...

+      dct_interleave8(p1, p3); // a4b4c4d4...

+

+      // store

+      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;

+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;

+      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;

+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;

+      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;

+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;

+      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;

+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));

+   }

+

+#undef dct_const

+#undef dct_rot

+#undef dct_widen

+#undef dct_wadd

+#undef dct_wsub

+#undef dct_bfly32o

+#undef dct_interleave8

+#undef dct_interleave16

+#undef dct_pass

+}

+

+#endif // STBI_SSE2

+

+#ifdef STBI_NEON

+

+// NEON integer IDCT. should produce bit-identical

+// results to the generic C version.

+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])

+{

+   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;

+

+   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));

+   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));

+   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));

+   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));

+   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));

+   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));

+   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));

+   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));

+   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));

+   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));

+   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));

+   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));

+

+#define dct_long_mul(out, inq, coeff) \

+   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \

+   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)

+

+#define dct_long_mac(out, acc, inq, coeff) \

+   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \

+   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)

+

+#define dct_widen(out, inq) \

+   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \

+   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)

+

+// wide add

+#define dct_wadd(out, a, b) \

+   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \

+   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)

+

+// wide sub

+#define dct_wsub(out, a, b) \

+   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \

+   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)

+

+// butterfly a/b, then shift using "shiftop" by "s" and pack

+#define dct_bfly32o(out0,out1, a,b,shiftop,s) \

+   { \

+      dct_wadd(sum, a, b); \

+      dct_wsub(dif, a, b); \

+      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \

+      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \

+   }

+

+#define dct_pass(shiftop, shift) \

+   { \

+      /* even part */ \

+      int16x8_t sum26 = vaddq_s16(row2, row6); \

+      dct_long_mul(p1e, sum26, rot0_0); \

+      dct_long_mac(t2e, p1e, row6, rot0_1); \

+      dct_long_mac(t3e, p1e, row2, rot0_2); \

+      int16x8_t sum04 = vaddq_s16(row0, row4); \

+      int16x8_t dif04 = vsubq_s16(row0, row4); \

+      dct_widen(t0e, sum04); \

+      dct_widen(t1e, dif04); \

+      dct_wadd(x0, t0e, t3e); \

+      dct_wsub(x3, t0e, t3e); \

+      dct_wadd(x1, t1e, t2e); \

+      dct_wsub(x2, t1e, t2e); \

+      /* odd part */ \

+      int16x8_t sum15 = vaddq_s16(row1, row5); \

+      int16x8_t sum17 = vaddq_s16(row1, row7); \

+      int16x8_t sum35 = vaddq_s16(row3, row5); \

+      int16x8_t sum37 = vaddq_s16(row3, row7); \

+      int16x8_t sumodd = vaddq_s16(sum17, sum35); \

+      dct_long_mul(p5o, sumodd, rot1_0); \

+      dct_long_mac(p1o, p5o, sum17, rot1_1); \

+      dct_long_mac(p2o, p5o, sum35, rot1_2); \

+      dct_long_mul(p3o, sum37, rot2_0); \

+      dct_long_mul(p4o, sum15, rot2_1); \

+      dct_wadd(sump13o, p1o, p3o); \

+      dct_wadd(sump24o, p2o, p4o); \

+      dct_wadd(sump23o, p2o, p3o); \

+      dct_wadd(sump14o, p1o, p4o); \

+      dct_long_mac(x4, sump13o, row7, rot3_0); \

+      dct_long_mac(x5, sump24o, row5, rot3_1); \

+      dct_long_mac(x6, sump23o, row3, rot3_2); \

+      dct_long_mac(x7, sump14o, row1, rot3_3); \

+      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \

+      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \

+      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \

+      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \

+   }

+

+   // load

+   row0 = vld1q_s16(data + 0*8);

+   row1 = vld1q_s16(data + 1*8);

+   row2 = vld1q_s16(data + 2*8);

+   row3 = vld1q_s16(data + 3*8);

+   row4 = vld1q_s16(data + 4*8);

+   row5 = vld1q_s16(data + 5*8);

+   row6 = vld1q_s16(data + 6*8);

+   row7 = vld1q_s16(data + 7*8);

+

+   // add DC bias

+   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));

+

+   // column pass

+   dct_pass(vrshrn_n_s32, 10);

+

+   // 16bit 8x8 transpose

+   {

+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.

+// whether compilers actually get this is another story, sadly.

+#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }

+#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }

+#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }

+

+      // pass 1

+      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6

+      dct_trn16(row2, row3);

+      dct_trn16(row4, row5);

+      dct_trn16(row6, row7);

+

+      // pass 2

+      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4

+      dct_trn32(row1, row3);

+      dct_trn32(row4, row6);

+      dct_trn32(row5, row7);

+

+      // pass 3

+      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0

+      dct_trn64(row1, row5);

+      dct_trn64(row2, row6);

+      dct_trn64(row3, row7);

+

+#undef dct_trn16

+#undef dct_trn32

+#undef dct_trn64

+   }

+

+   // row pass

+   // vrshrn_n_s32 only supports shifts up to 16, we need

+   // 17. so do a non-rounding shift of 16 first then follow

+   // up with a rounding shift by 1.

+   dct_pass(vshrn_n_s32, 16);

+

+   {

+      // pack and round

+      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);

+      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);

+      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);

+      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);

+      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);

+      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);

+      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);

+      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);

+

+      // again, these can translate into one instruction, but often don't.

+#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }

+#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }

+#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }

+

+      // sadly can't use interleaved stores here since we only write

+      // 8 bytes to each scan line!

+

+      // 8x8 8-bit transpose pass 1

+      dct_trn8_8(p0, p1);

+      dct_trn8_8(p2, p3);

+      dct_trn8_8(p4, p5);

+      dct_trn8_8(p6, p7);

+

+      // pass 2

+      dct_trn8_16(p0, p2);

+      dct_trn8_16(p1, p3);

+      dct_trn8_16(p4, p6);

+      dct_trn8_16(p5, p7);

+

+      // pass 3

+      dct_trn8_32(p0, p4);

+      dct_trn8_32(p1, p5);

+      dct_trn8_32(p2, p6);

+      dct_trn8_32(p3, p7);

+

+      // store

+      vst1_u8(out, p0); out += out_stride;

+      vst1_u8(out, p1); out += out_stride;

+      vst1_u8(out, p2); out += out_stride;

+      vst1_u8(out, p3); out += out_stride;

+      vst1_u8(out, p4); out += out_stride;

+      vst1_u8(out, p5); out += out_stride;

+      vst1_u8(out, p6); out += out_stride;

+      vst1_u8(out, p7);

+

+#undef dct_trn8_8

+#undef dct_trn8_16

+#undef dct_trn8_32

+   }

+

+#undef dct_long_mul

+#undef dct_long_mac

+#undef dct_widen

+#undef dct_wadd

+#undef dct_wsub

+#undef dct_bfly32o

+#undef dct_pass

+}

+

+#endif // STBI_NEON

+

+#define STBI__MARKER_none  0xff

+// if there's a pending marker from the entropy stream, return that

+// otherwise, fetch from the stream and get a marker. if there's no

+// marker, return 0xff, which is never a valid marker value

+static stbi_uc stbi__get_marker(stbi__jpeg *j)

+{

+   stbi_uc x;

+   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }

+   x = stbi__get8(j->s);

+   if (x != 0xff) return STBI__MARKER_none;

+   while (x == 0xff)

+      x = stbi__get8(j->s); // consume repeated 0xff fill bytes

+   return x;

+}

+

+// in each scan, we'll have scan_n components, and the order

+// of the components is specified by order[]

+#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)

+

+// after a restart interval, stbi__jpeg_reset the entropy decoder and

+// the dc prediction

+static void stbi__jpeg_reset(stbi__jpeg *j)

+{

+   j->code_bits = 0;

+   j->code_buffer = 0;

+   j->nomore = 0;

+   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;

+   j->marker = STBI__MARKER_none;

+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;

+   j->eob_run = 0;

+   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,

+   // since we don't even allow 1<<30 pixels

+}

+

+static int stbi__parse_entropy_coded_data(stbi__jpeg *z)

+{

+   stbi__jpeg_reset(z);

+   if (!z->progressive) {

+      if (z->scan_n == 1) {

+         int i,j;

+         STBI_SIMD_ALIGN(short, data[64]);

+         int n = z->order[0];

+         // non-interleaved data, we just need to process one block at a time,

+         // in trivial scanline order

+         // number of blocks to do just depends on how many actual "pixels" this

+         // component has, independent of interleaved MCU blocking and such

+         int w = (z->img_comp[n].x+7) >> 3;

+         int h = (z->img_comp[n].y+7) >> 3;

+         for (j=0; j < h; ++j) {

+            for (i=0; i < w; ++i) {

+               int ha = z->img_comp[n].ha;

+               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;

+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);

+               // every data block is an MCU, so countdown the restart interval

+               if (--z->todo <= 0) {

+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);

+                  // if it's NOT a restart, then just bail, so we get corrupt data

+                  // rather than no data

+                  if (!STBI__RESTART(z->marker)) return 1;

+                  stbi__jpeg_reset(z);

+               }

+            }

+         }

+         return 1;

+      } else { // interleaved

+         int i,j,k,x,y;

+         STBI_SIMD_ALIGN(short, data[64]);

+         for (j=0; j < z->img_mcu_y; ++j) {

+            for (i=0; i < z->img_mcu_x; ++i) {

+               // scan an interleaved mcu... process scan_n components in order

+               for (k=0; k < z->scan_n; ++k) {

+                  int n = z->order[k];

+                  // scan out an mcu's worth of this component; that's just determined

+                  // by the basic H and V specified for the component

+                  for (y=0; y < z->img_comp[n].v; ++y) {

+                     for (x=0; x < z->img_comp[n].h; ++x) {

+                        int x2 = (i*z->img_comp[n].h + x)*8;

+                        int y2 = (j*z->img_comp[n].v + y)*8;

+                        int ha = z->img_comp[n].ha;

+                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;

+                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);

+                     }

+                  }

+               }

+               // after all interleaved components, that's an interleaved MCU,

+               // so now count down the restart interval

+               if (--z->todo <= 0) {

+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);

+                  if (!STBI__RESTART(z->marker)) return 1;

+                  stbi__jpeg_reset(z);

+               }

+            }

+         }

+         return 1;

+      }

+   } else {

+      if (z->scan_n == 1) {

+         int i,j;

+         int n = z->order[0];

+         // non-interleaved data, we just need to process one block at a time,

+         // in trivial scanline order

+         // number of blocks to do just depends on how many actual "pixels" this

+         // component has, independent of interleaved MCU blocking and such

+         int w = (z->img_comp[n].x+7) >> 3;

+         int h = (z->img_comp[n].y+7) >> 3;

+         for (j=0; j < h; ++j) {

+            for (i=0; i < w; ++i) {

+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);

+               if (z->spec_start == 0) {

+                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))

+                     return 0;

+               } else {

+                  int ha = z->img_comp[n].ha;

+                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))

+                     return 0;

+               }

+               // every data block is an MCU, so countdown the restart interval

+               if (--z->todo <= 0) {

+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);

+                  if (!STBI__RESTART(z->marker)) return 1;

+                  stbi__jpeg_reset(z);

+               }

+            }

+         }

+         return 1;

+      } else { // interleaved

+         int i,j,k,x,y;

+         for (j=0; j < z->img_mcu_y; ++j) {

+            for (i=0; i < z->img_mcu_x; ++i) {

+               // scan an interleaved mcu... process scan_n components in order

+               for (k=0; k < z->scan_n; ++k) {

+                  int n = z->order[k];

+                  // scan out an mcu's worth of this component; that's just determined

+                  // by the basic H and V specified for the component

+                  for (y=0; y < z->img_comp[n].v; ++y) {

+                     for (x=0; x < z->img_comp[n].h; ++x) {

+                        int x2 = (i*z->img_comp[n].h + x);

+                        int y2 = (j*z->img_comp[n].v + y);

+                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);

+                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))

+                           return 0;

+                     }

+                  }

+               }

+               // after all interleaved components, that's an interleaved MCU,

+               // so now count down the restart interval

+               if (--z->todo <= 0) {

+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);

+                  if (!STBI__RESTART(z->marker)) return 1;

+                  stbi__jpeg_reset(z);

+               }

+            }

+         }

+         return 1;

+      }

+   }

+}

+

+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)

+{

+   int i;

+   for (i=0; i < 64; ++i)

+      data[i] *= dequant[i];

+}

+

+static void stbi__jpeg_finish(stbi__jpeg *z)

+{

+   if (z->progressive) {

+      // dequantize and idct the data

+      int i,j,n;

+      for (n=0; n < z->s->img_n; ++n) {

+         int w = (z->img_comp[n].x+7) >> 3;

+         int h = (z->img_comp[n].y+7) >> 3;

+         for (j=0; j < h; ++j) {

+            for (i=0; i < w; ++i) {

+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);

+               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);

+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);

+            }

+         }

+      }

+   }

+}

+

+static int stbi__process_marker(stbi__jpeg *z, int m)

+{

+   int L;

+   switch (m) {

+      case STBI__MARKER_none: // no marker found

+         return stbi__err("expected marker","Corrupt JPEG");

+

+      case 0xDD: // DRI - specify restart interval

+         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");

+         z->restart_interval = stbi__get16be(z->s);

+         return 1;

+

+      case 0xDB: // DQT - define quantization table

+         L = stbi__get16be(z->s)-2;

+         while (L > 0) {

+            int q = stbi__get8(z->s);

+            int p = q >> 4, sixteen = (p != 0);

+            int t = q & 15,i;

+            if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");

+            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");

+

+            for (i=0; i < 64; ++i)

+               z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));

+            L -= (sixteen ? 129 : 65);

+         }

+         return L==0;

+

+      case 0xC4: // DHT - define huffman table

+         L = stbi__get16be(z->s)-2;

+         while (L > 0) {

+            stbi_uc *v;

+            int sizes[16],i,n=0;

+            int q = stbi__get8(z->s);

+            int tc = q >> 4;

+            int th = q & 15;

+            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");

+            for (i=0; i < 16; ++i) {

+               sizes[i] = stbi__get8(z->s);

+               n += sizes[i];

+            }

+            L -= 17;

+            if (tc == 0) {

+               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;

+               v = z->huff_dc[th].values;

+            } else {

+               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;

+               v = z->huff_ac[th].values;

+            }

+            for (i=0; i < n; ++i)

+               v[i] = stbi__get8(z->s);

+            if (tc != 0)

+               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);

+            L -= n;

+         }

+         return L==0;

+   }

+

+   // check for comment block or APP blocks

+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {

+      L = stbi__get16be(z->s);

+      if (L < 2) {

+         if (m == 0xFE)

+            return stbi__err("bad COM len","Corrupt JPEG");

+         else

+            return stbi__err("bad APP len","Corrupt JPEG");

+      }

+      L -= 2;

+

+      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment

+         static const unsigned char tag[5] = {'J','F','I','F','\0'};

+         int ok = 1;

+         int i;

+         for (i=0; i < 5; ++i)

+            if (stbi__get8(z->s) != tag[i])

+               ok = 0;

+         L -= 5;

+         if (ok)

+            z->jfif = 1;

+      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment

+         static const unsigned char tag[6] = {'A','d','o','b','e','\0'};

+         int ok = 1;

+         int i;

+         for (i=0; i < 6; ++i)

+            if (stbi__get8(z->s) != tag[i])

+               ok = 0;

+         L -= 6;

+         if (ok) {

+            stbi__get8(z->s); // version

+            stbi__get16be(z->s); // flags0

+            stbi__get16be(z->s); // flags1

+            z->app14_color_transform = stbi__get8(z->s); // color transform

+            L -= 6;

+         }

+      }

+

+      stbi__skip(z->s, L);

+      return 1;

+   }

+

+   return stbi__err("unknown marker","Corrupt JPEG");

+}

+

+// after we see SOS

+static int stbi__process_scan_header(stbi__jpeg *z)

+{

+   int i;

+   int Ls = stbi__get16be(z->s);

+   z->scan_n = stbi__get8(z->s);

+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");

+   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");

+   for (i=0; i < z->scan_n; ++i) {

+      int id = stbi__get8(z->s), which;

+      int q = stbi__get8(z->s);

+      for (which = 0; which < z->s->img_n; ++which)

+         if (z->img_comp[which].id == id)

+            break;

+      if (which == z->s->img_n) return 0; // no match

+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");

+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");

+      z->order[i] = which;

+   }

+

+   {

+      int aa;

+      z->spec_start = stbi__get8(z->s);

+      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0

+      aa = stbi__get8(z->s);

+      z->succ_high = (aa >> 4);

+      z->succ_low  = (aa & 15);

+      if (z->progressive) {

+         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)

+            return stbi__err("bad SOS", "Corrupt JPEG");

+      } else {

+         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");

+         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");

+         z->spec_end = 63;

+      }

+   }

+

+   return 1;

+}

+

+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)

+{

+   int i;

+   for (i=0; i < ncomp; ++i) {

+      if (z->img_comp[i].raw_data) {

+         STBI_FREE(z->img_comp[i].raw_data);

+         z->img_comp[i].raw_data = NULL;

+         z->img_comp[i].data = NULL;

+      }

+      if (z->img_comp[i].raw_coeff) {

+         STBI_FREE(z->img_comp[i].raw_coeff);

+         z->img_comp[i].raw_coeff = 0;

+         z->img_comp[i].coeff = 0;

+      }

+      if (z->img_comp[i].linebuf) {

+         STBI_FREE(z->img_comp[i].linebuf);

+         z->img_comp[i].linebuf = NULL;

+      }

+   }

+   return why;

+}

+

+static int stbi__process_frame_header(stbi__jpeg *z, int scan)

+{

+   stbi__context *s = z->s;

+   int Lf,p,i,q, h_max=1,v_max=1,c;

+   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG

+   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline

+   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG

+   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires

+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");

+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");

+   c = stbi__get8(s);

+   if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");

+   s->img_n = c;

+   for (i=0; i < c; ++i) {

+      z->img_comp[i].data = NULL;

+      z->img_comp[i].linebuf = NULL;

+   }

+

+   if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");

+

+   z->rgb = 0;

+   for (i=0; i < s->img_n; ++i) {

+      static const unsigned char rgb[3] = { 'R', 'G', 'B' };

+      z->img_comp[i].id = stbi__get8(s);

+      if (s->img_n == 3 && z->img_comp[i].id == rgb[i])

+         ++z->rgb;

+      q = stbi__get8(s);

+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");

+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");

+      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");

+   }

+

+   if (scan != STBI__SCAN_load) return 1;

+

+   if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");

+

+   for (i=0; i < s->img_n; ++i) {

+      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;

+      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;

+   }

+

+   // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios

+   // and I've never seen a non-corrupted JPEG file actually use them

+   for (i=0; i < s->img_n; ++i) {

+      if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");

+      if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");

+   }

+

+   // compute interleaved mcu info

+   z->img_h_max = h_max;

+   z->img_v_max = v_max;

+   z->img_mcu_w = h_max * 8;

+   z->img_mcu_h = v_max * 8;

+   // these sizes can't be more than 17 bits

+   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;

+   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;

+

+   for (i=0; i < s->img_n; ++i) {

+      // number of effective pixels (e.g. for non-interleaved MCU)

+      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;

+      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;

+      // to simplify generation, we'll allocate enough memory to decode

+      // the bogus oversized data from using interleaved MCUs and their

+      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't

+      // discard the extra data until colorspace conversion

+      //

+      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)

+      // so these muls can't overflow with 32-bit ints (which we require)

+      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;

+      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;

+      z->img_comp[i].coeff = 0;

+      z->img_comp[i].raw_coeff = 0;

+      z->img_comp[i].linebuf = NULL;

+      z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);

+      if (z->img_comp[i].raw_data == NULL)

+         return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));

+      // align blocks for idct using mmx/sse

+      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);

+      if (z->progressive) {

+         // w2, h2 are multiples of 8 (see above)

+         z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;

+         z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;

+         z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);

+         if (z->img_comp[i].raw_coeff == NULL)

+            return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));

+         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);

+      }

+   }

+

+   return 1;

+}

+

+// use comparisons since in some cases we handle more than one case (e.g. SOF)

+#define stbi__DNL(x)         ((x) == 0xdc)

+#define stbi__SOI(x)         ((x) == 0xd8)

+#define stbi__EOI(x)         ((x) == 0xd9)

+#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)

+#define stbi__SOS(x)         ((x) == 0xda)

+

+#define stbi__SOF_progressive(x)   ((x) == 0xc2)

+

+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)

+{

+   int m;

+   z->jfif = 0;

+   z->app14_color_transform = -1; // valid values are 0,1,2

+   z->marker = STBI__MARKER_none; // initialize cached marker to empty

+   m = stbi__get_marker(z);

+   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");

+   if (scan == STBI__SCAN_type) return 1;

+   m = stbi__get_marker(z);

+   while (!stbi__SOF(m)) {

+      if (!stbi__process_marker(z,m)) return 0;

+      m = stbi__get_marker(z);

+      while (m == STBI__MARKER_none) {

+         // some files have extra padding after their blocks, so ok, we'll scan

+         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");

+         m = stbi__get_marker(z);

+      }

+   }

+   z->progressive = stbi__SOF_progressive(m);

+   if (!stbi__process_frame_header(z, scan)) return 0;

+   return 1;

+}

+

+// decode image to YCbCr format

+static int stbi__decode_jpeg_image(stbi__jpeg *j)

+{

+   int m;

+   for (m = 0; m < 4; m++) {

+      j->img_comp[m].raw_data = NULL;

+      j->img_comp[m].raw_coeff = NULL;

+   }

+   j->restart_interval = 0;

+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;

+   m = stbi__get_marker(j);

+   while (!stbi__EOI(m)) {

+      if (stbi__SOS(m)) {

+         if (!stbi__process_scan_header(j)) return 0;

+         if (!stbi__parse_entropy_coded_data(j)) return 0;

+         if (j->marker == STBI__MARKER_none ) {

+            // handle 0s at the end of image data from IP Kamera 9060

+            while (!stbi__at_eof(j->s)) {

+               int x = stbi__get8(j->s);

+               if (x == 255) {

+                  j->marker = stbi__get8(j->s);

+                  break;

+               }

+            }

+            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0

+         }

+      } else if (stbi__DNL(m)) {

+         int Ld = stbi__get16be(j->s);

+         stbi__uint32 NL = stbi__get16be(j->s);

+         if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");

+         if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");

+      } else {

+         if (!stbi__process_marker(j, m)) return 0;

+      }

+      m = stbi__get_marker(j);

+   }

+   if (j->progressive)

+      stbi__jpeg_finish(j);

+   return 1;

+}

+

+// static jfif-centered resampling (across block boundaries)

+

+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,

+                                    int w, int hs);

+

+#define stbi__div4(x) ((stbi_uc) ((x) >> 2))

+

+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)

+{

+   STBI_NOTUSED(out);

+   STBI_NOTUSED(in_far);

+   STBI_NOTUSED(w);

+   STBI_NOTUSED(hs);

+   return in_near;

+}

+

+static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)

+{

+   // need to generate two samples vertically for every one in input

+   int i;

+   STBI_NOTUSED(hs);

+   for (i=0; i < w; ++i)

+      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);

+   return out;

+}

+

+static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)

+{

+   // need to generate two samples horizontally for every one in input

+   int i;

+   stbi_uc *input = in_near;

+

+   if (w == 1) {

+      // if only one sample, can't do any interpolation

+      out[0] = out[1] = input[0];

+      return out;

+   }

+

+   out[0] = input[0];

+   out[1] = stbi__div4(input[0]*3 + input[1] + 2);

+   for (i=1; i < w-1; ++i) {

+      int n = 3*input[i]+2;

+      out[i*2+0] = stbi__div4(n+input[i-1]);

+      out[i*2+1] = stbi__div4(n+input[i+1]);

+   }

+   out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);

+   out[i*2+1] = input[w-1];

+

+   STBI_NOTUSED(in_far);

+   STBI_NOTUSED(hs);

+

+   return out;

+}

+

+#define stbi__div16(x) ((stbi_uc) ((x) >> 4))

+

+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)

+{

+   // need to generate 2x2 samples for every one in input

+   int i,t0,t1;

+   if (w == 1) {

+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);

+      return out;

+   }

+

+   t1 = 3*in_near[0] + in_far[0];

+   out[0] = stbi__div4(t1+2);

+   for (i=1; i < w; ++i) {

+      t0 = t1;

+      t1 = 3*in_near[i]+in_far[i];

+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);

+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);

+   }

+   out[w*2-1] = stbi__div4(t1+2);

+

+   STBI_NOTUSED(hs);

+

+   return out;

+}

+

+#if defined(STBI_SSE2) || defined(STBI_NEON)

+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)

+{

+   // need to generate 2x2 samples for every one in input

+   int i=0,t0,t1;

+

+   if (w == 1) {

+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);

+      return out;

+   }

+

+   t1 = 3*in_near[0] + in_far[0];

+   // process groups of 8 pixels for as long as we can.

+   // note we can't handle the last pixel in a row in this loop

+   // because we need to handle the filter boundary conditions.

+   for (; i < ((w-1) & ~7); i += 8) {

+#if defined(STBI_SSE2)

+      // load and perform the vertical filtering pass

+      // this uses 3*x + y = 4*x + (y - x)

+      __m128i zero  = _mm_setzero_si128();

+      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));

+      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));

+      __m128i farw  = _mm_unpacklo_epi8(farb, zero);

+      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);

+      __m128i diff  = _mm_sub_epi16(farw, nearw);

+      __m128i nears = _mm_slli_epi16(nearw, 2);

+      __m128i curr  = _mm_add_epi16(nears, diff); // current row

+

+      // horizontal filter works the same based on shifted vers of current

+      // row. "prev" is current row shifted right by 1 pixel; we need to

+      // insert the previous pixel value (from t1).

+      // "next" is current row shifted left by 1 pixel, with first pixel

+      // of next block of 8 pixels added in.

+      __m128i prv0 = _mm_slli_si128(curr, 2);

+      __m128i nxt0 = _mm_srli_si128(curr, 2);

+      __m128i prev = _mm_insert_epi16(prv0, t1, 0);

+      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);

+

+      // horizontal filter, polyphase implementation since it's convenient:

+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)

+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)

+      // note the shared term.

+      __m128i bias  = _mm_set1_epi16(8);

+      __m128i curs = _mm_slli_epi16(curr, 2);

+      __m128i prvd = _mm_sub_epi16(prev, curr);

+      __m128i nxtd = _mm_sub_epi16(next, curr);

+      __m128i curb = _mm_add_epi16(curs, bias);

+      __m128i even = _mm_add_epi16(prvd, curb);

+      __m128i odd  = _mm_add_epi16(nxtd, curb);

+

+      // interleave even and odd pixels, then undo scaling.

+      __m128i int0 = _mm_unpacklo_epi16(even, odd);

+      __m128i int1 = _mm_unpackhi_epi16(even, odd);

+      __m128i de0  = _mm_srli_epi16(int0, 4);

+      __m128i de1  = _mm_srli_epi16(int1, 4);

+

+      // pack and write output

+      __m128i outv = _mm_packus_epi16(de0, de1);

+      _mm_storeu_si128((__m128i *) (out + i*2), outv);

+#elif defined(STBI_NEON)

+      // load and perform the vertical filtering pass

+      // this uses 3*x + y = 4*x + (y - x)

+      uint8x8_t farb  = vld1_u8(in_far + i);

+      uint8x8_t nearb = vld1_u8(in_near + i);

+      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));

+      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));

+      int16x8_t curr  = vaddq_s16(nears, diff); // current row

+

+      // horizontal filter works the same based on shifted vers of current

+      // row. "prev" is current row shifted right by 1 pixel; we need to

+      // insert the previous pixel value (from t1).

+      // "next" is current row shifted left by 1 pixel, with first pixel

+      // of next block of 8 pixels added in.

+      int16x8_t prv0 = vextq_s16(curr, curr, 7);

+      int16x8_t nxt0 = vextq_s16(curr, curr, 1);

+      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);

+      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);

+

+      // horizontal filter, polyphase implementation since it's convenient:

+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)

+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)

+      // note the shared term.

+      int16x8_t curs = vshlq_n_s16(curr, 2);

+      int16x8_t prvd = vsubq_s16(prev, curr);

+      int16x8_t nxtd = vsubq_s16(next, curr);

+      int16x8_t even = vaddq_s16(curs, prvd);

+      int16x8_t odd  = vaddq_s16(curs, nxtd);

+

+      // undo scaling and round, then store with even/odd phases interleaved

+      uint8x8x2_t o;

+      o.val[0] = vqrshrun_n_s16(even, 4);

+      o.val[1] = vqrshrun_n_s16(odd,  4);

+      vst2_u8(out + i*2, o);

+#endif

+

+      // "previous" value for next iter

+      t1 = 3*in_near[i+7] + in_far[i+7];

+   }

+

+   t0 = t1;

+   t1 = 3*in_near[i] + in_far[i];

+   out[i*2] = stbi__div16(3*t1 + t0 + 8);

+

+   for (++i; i < w; ++i) {

+      t0 = t1;

+      t1 = 3*in_near[i]+in_far[i];

+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);

+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);

+   }

+   out[w*2-1] = stbi__div4(t1+2);

+

+   STBI_NOTUSED(hs);

+

+   return out;

+}

+#endif

+

+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)

+{

+   // resample with nearest-neighbor

+   int i,j;

+   STBI_NOTUSED(in_far);

+   for (i=0; i < w; ++i)

+      for (j=0; j < hs; ++j)

+         out[i*hs+j] = in_near[i];

+   return out;

+}

+

+// this is a reduced-precision calculation of YCbCr-to-RGB introduced

+// to make sure the code produces the same results in both SIMD and scalar

+#define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)

+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)

+{

+   int i;

+   for (i=0; i < count; ++i) {

+      int y_fixed = (y[i] << 20) + (1<<19); // rounding

+      int r,g,b;

+      int cr = pcr[i] - 128;

+      int cb = pcb[i] - 128;

+      r = y_fixed +  cr* stbi__float2fixed(1.40200f);

+      g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);

+      b = y_fixed                                     +   cb* stbi__float2fixed(1.77200f);

+      r >>= 20;

+      g >>= 20;

+      b >>= 20;

+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }

+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }

+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }

+      out[0] = (stbi_uc)r;

+      out[1] = (stbi_uc)g;

+      out[2] = (stbi_uc)b;

+      out[3] = 255;

+      out += step;

+   }

+}

+

+#if defined(STBI_SSE2) || defined(STBI_NEON)

+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)

+{

+   int i = 0;

+

+#ifdef STBI_SSE2

+   // step == 3 is pretty ugly on the final interleave, and i'm not convinced

+   // it's useful in practice (you wouldn't use it for textures, for example).

+   // so just accelerate step == 4 case.

+   if (step == 4) {

+      // this is a fairly straightforward implementation and not super-optimized.

+      __m128i signflip  = _mm_set1_epi8(-0x80);

+      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));

+      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));

+      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));

+      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));

+      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);

+      __m128i xw = _mm_set1_epi16(255); // alpha channel

+

+      for (; i+7 < count; i += 8) {

+         // load

+         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));

+         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));

+         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));

+         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128

+         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128

+

+         // unpack to short (and left-shift cr, cb by 8)

+         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);

+         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);

+         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);

+

+         // color transform

+         __m128i yws = _mm_srli_epi16(yw, 4);

+         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);

+         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);

+         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);

+         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);

+         __m128i rws = _mm_add_epi16(cr0, yws);

+         __m128i gwt = _mm_add_epi16(cb0, yws);

+         __m128i bws = _mm_add_epi16(yws, cb1);

+         __m128i gws = _mm_add_epi16(gwt, cr1);

+

+         // descale

+         __m128i rw = _mm_srai_epi16(rws, 4);

+         __m128i bw = _mm_srai_epi16(bws, 4);

+         __m128i gw = _mm_srai_epi16(gws, 4);

+

+         // back to byte, set up for transpose

+         __m128i brb = _mm_packus_epi16(rw, bw);

+         __m128i gxb = _mm_packus_epi16(gw, xw);

+

+         // transpose to interleave channels

+         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);

+         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);

+         __m128i o0 = _mm_unpacklo_epi16(t0, t1);

+         __m128i o1 = _mm_unpackhi_epi16(t0, t1);

+

+         // store

+         _mm_storeu_si128((__m128i *) (out + 0), o0);

+         _mm_storeu_si128((__m128i *) (out + 16), o1);

+         out += 32;

+      }

+   }

+#endif

+

+#ifdef STBI_NEON

+   // in this version, step=3 support would be easy to add. but is there demand?

+   if (step == 4) {

+      // this is a fairly straightforward implementation and not super-optimized.

+      uint8x8_t signflip = vdup_n_u8(0x80);

+      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));

+      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));

+      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));

+      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));

+

+      for (; i+7 < count; i += 8) {

+         // load

+         uint8x8_t y_bytes  = vld1_u8(y + i);

+         uint8x8_t cr_bytes = vld1_u8(pcr + i);

+         uint8x8_t cb_bytes = vld1_u8(pcb + i);

+         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));

+         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));

+

+         // expand to s16

+         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));

+         int16x8_t crw = vshll_n_s8(cr_biased, 7);

+         int16x8_t cbw = vshll_n_s8(cb_biased, 7);

+

+         // color transform

+         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);

+         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);

+         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);

+         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);

+         int16x8_t rws = vaddq_s16(yws, cr0);

+         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);

+         int16x8_t bws = vaddq_s16(yws, cb1);

+

+         // undo scaling, round, convert to byte

+         uint8x8x4_t o;

+         o.val[0] = vqrshrun_n_s16(rws, 4);

+         o.val[1] = vqrshrun_n_s16(gws, 4);

+         o.val[2] = vqrshrun_n_s16(bws, 4);

+         o.val[3] = vdup_n_u8(255);

+

+         // store, interleaving r/g/b/a

+         vst4_u8(out, o);

+         out += 8*4;

+      }

+   }

+#endif

+

+   for (; i < count; ++i) {

+      int y_fixed = (y[i] << 20) + (1<<19); // rounding

+      int r,g,b;

+      int cr = pcr[i] - 128;

+      int cb = pcb[i] - 128;

+      r = y_fixed + cr* stbi__float2fixed(1.40200f);

+      g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);

+      b = y_fixed                                   +   cb* stbi__float2fixed(1.77200f);

+      r >>= 20;

+      g >>= 20;

+      b >>= 20;

+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }

+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }

+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }

+      out[0] = (stbi_uc)r;

+      out[1] = (stbi_uc)g;

+      out[2] = (stbi_uc)b;

+      out[3] = 255;

+      out += step;

+   }

+}

+#endif

+

+// set up the kernels

+static void stbi__setup_jpeg(stbi__jpeg *j)

+{

+   j->idct_block_kernel = stbi__idct_block;

+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;

+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;

+

+#ifdef STBI_SSE2

+   if (stbi__sse2_available()) {

+      j->idct_block_kernel = stbi__idct_simd;

+      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;

+      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;

+   }

+#endif

+

+#ifdef STBI_NEON

+   j->idct_block_kernel = stbi__idct_simd;

+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;

+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;

+#endif

+}

+

+// clean up the temporary component buffers

+static void stbi__cleanup_jpeg(stbi__jpeg *j)

+{

+   stbi__free_jpeg_components(j, j->s->img_n, 0);

+}

+

+typedef struct

+{

+   resample_row_func resample;

+   stbi_uc *line0,*line1;

+   int hs,vs;   // expansion factor in each axis

+   int w_lores; // horizontal pixels pre-expansion

+   int ystep;   // how far through vertical expansion we are

+   int ypos;    // which pre-expansion row we're on

+} stbi__resample;

+

+// fast 0..255 * 0..255 => 0..255 rounded multiplication

+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)

+{

+   unsigned int t = x*y + 128;

+   return (stbi_uc) ((t + (t >>8)) >> 8);

+}

+

+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)

+{

+   int n, decode_n, is_rgb;

+   z->s->img_n = 0; // make stbi__cleanup_jpeg safe

+

+   // validate req_comp

+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");

+

+   // load a jpeg image from whichever source, but leave in YCbCr format

+   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }

+

+   // determine actual number of components to generate

+   n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;

+

+   is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));

+

+   if (z->s->img_n == 3 && n < 3 && !is_rgb)

+      decode_n = 1;

+   else

+      decode_n = z->s->img_n;

+

+   // nothing to do if no components requested; check this now to avoid

+   // accessing uninitialized coutput[0] later

+   if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }

+

+   // resample and color-convert

+   {

+      int k;

+      unsigned int i,j;

+      stbi_uc *output;

+      stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };

+

+      stbi__resample res_comp[4];

+

+      for (k=0; k < decode_n; ++k) {

+         stbi__resample *r = &res_comp[k];

+

+         // allocate line buffer big enough for upsampling off the edges

+         // with upsample factor of 4

+         z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);

+         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }

+

+         r->hs      = z->img_h_max / z->img_comp[k].h;

+         r->vs      = z->img_v_max / z->img_comp[k].v;

+         r->ystep   = r->vs >> 1;

+         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;

+         r->ypos    = 0;

+         r->line0   = r->line1 = z->img_comp[k].data;

+

+         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;

+         else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;

+         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;

+         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;

+         else                               r->resample = stbi__resample_row_generic;

+      }

+

+      // can't error after this so, this is safe

+      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);

+      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }

+

+      // now go ahead and resample

+      for (j=0; j < z->s->img_y; ++j) {

+         stbi_uc *out = output + n * z->s->img_x * j;

+         for (k=0; k < decode_n; ++k) {

+            stbi__resample *r = &res_comp[k];

+            int y_bot = r->ystep >= (r->vs >> 1);

+            coutput[k] = r->resample(z->img_comp[k].linebuf,

+                                     y_bot ? r->line1 : r->line0,

+                                     y_bot ? r->line0 : r->line1,

+                                     r->w_lores, r->hs);

+            if (++r->ystep >= r->vs) {

+               r->ystep = 0;

+               r->line0 = r->line1;

+               if (++r->ypos < z->img_comp[k].y)

+                  r->line1 += z->img_comp[k].w2;

+            }

+         }

+         if (n >= 3) {

+            stbi_uc *y = coutput[0];

+            if (z->s->img_n == 3) {

+               if (is_rgb) {

+                  for (i=0; i < z->s->img_x; ++i) {

+                     out[0] = y[i];

+                     out[1] = coutput[1][i];

+                     out[2] = coutput[2][i];

+                     out[3] = 255;

+                     out += n;

+                  }

+               } else {

+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);

+               }

+            } else if (z->s->img_n == 4) {

+               if (z->app14_color_transform == 0) { // CMYK

+                  for (i=0; i < z->s->img_x; ++i) {

+                     stbi_uc m = coutput[3][i];

+                     out[0] = stbi__blinn_8x8(coutput[0][i], m);

+                     out[1] = stbi__blinn_8x8(coutput[1][i], m);

+                     out[2] = stbi__blinn_8x8(coutput[2][i], m);

+                     out[3] = 255;

+                     out += n;

+                  }

+               } else if (z->app14_color_transform == 2) { // YCCK

+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);

+                  for (i=0; i < z->s->img_x; ++i) {

+                     stbi_uc m = coutput[3][i];

+                     out[0] = stbi__blinn_8x8(255 - out[0], m);

+                     out[1] = stbi__blinn_8x8(255 - out[1], m);

+                     out[2] = stbi__blinn_8x8(255 - out[2], m);

+                     out += n;

+                  }

+               } else { // YCbCr + alpha?  Ignore the fourth channel for now

+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);

+               }

+            } else

+               for (i=0; i < z->s->img_x; ++i) {

+                  out[0] = out[1] = out[2] = y[i];

+                  out[3] = 255; // not used if n==3

+                  out += n;

+               }

+         } else {

+            if (is_rgb) {

+               if (n == 1)

+                  for (i=0; i < z->s->img_x; ++i)

+                     *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);

+               else {

+                  for (i=0; i < z->s->img_x; ++i, out += 2) {

+                     out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);

+                     out[1] = 255;

+                  }

+               }

+            } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {

+               for (i=0; i < z->s->img_x; ++i) {

+                  stbi_uc m = coutput[3][i];

+                  stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);

+                  stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);

+                  stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);

+                  out[0] = stbi__compute_y(r, g, b);

+                  out[1] = 255;

+                  out += n;

+               }

+            } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {

+               for (i=0; i < z->s->img_x; ++i) {

+                  out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);

+                  out[1] = 255;

+                  out += n;

+               }

+            } else {

+               stbi_uc *y = coutput[0];

+               if (n == 1)

+                  for (i=0; i < z->s->img_x; ++i) out[i] = y[i];

+               else

+                  for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }

+            }

+         }

+      }

+      stbi__cleanup_jpeg(z);

+      *out_x = z->s->img_x;

+      *out_y = z->s->img_y;

+      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output

+      return output;

+   }

+}

+

+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)

+{

+   unsigned char* result;

+   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));

+   if (!j) return stbi__errpuc("outofmem", "Out of memory");

+   STBI_NOTUSED(ri);

+   j->s = s;

+   stbi__setup_jpeg(j);

+   result = load_jpeg_image(j, x,y,comp,req_comp);

+   STBI_FREE(j);

+   return result;

+}

+

+static int stbi__jpeg_test(stbi__context *s)

+{

+   int r;

+   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));

+   if (!j) return stbi__err("outofmem", "Out of memory");

+   j->s = s;

+   stbi__setup_jpeg(j);

+   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);

+   stbi__rewind(s);

+   STBI_FREE(j);

+   return r;

+}

+

+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)

+{

+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {

+      stbi__rewind( j->s );

+      return 0;

+   }

+   if (x) *x = j->s->img_x;

+   if (y) *y = j->s->img_y;

+   if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;

+   return 1;

+}

+

+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   int result;

+   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));

+   if (!j) return stbi__err("outofmem", "Out of memory");

+   j->s = s;

+   result = stbi__jpeg_info_raw(j, x, y, comp);

+   STBI_FREE(j);

+   return result;

+}

+#endif

+

+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18

+//    simple implementation

+//      - all input must be provided in an upfront buffer

+//      - all output is written to a single output buffer (can malloc/realloc)

+//    performance

+//      - fast huffman

+

+#ifndef STBI_NO_ZLIB

+

+// fast-way is faster to check than jpeg huffman, but slow way is slower

+#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables

+#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)

+#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet

+

+// zlib-style huffman encoding

+// (jpegs packs from left, zlib from right, so can't share code)

+typedef struct

+{

+   stbi__uint16 fast[1 << STBI__ZFAST_BITS];

+   stbi__uint16 firstcode[16];

+   int maxcode[17];

+   stbi__uint16 firstsymbol[16];

+   stbi_uc  size[STBI__ZNSYMS];

+   stbi__uint16 value[STBI__ZNSYMS];

+} stbi__zhuffman;

+

+stbi_inline static int stbi__bitreverse16(int n)

+{

+  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);

+  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);

+  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);

+  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);

+  return n;

+}

+

+stbi_inline static int stbi__bit_reverse(int v, int bits)

+{

+   STBI_ASSERT(bits <= 16);

+   // to bit reverse n bits, reverse 16 and shift

+   // e.g. 11 bits, bit reverse and shift away 5

+   return stbi__bitreverse16(v) >> (16-bits);

+}

+

+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)

+{

+   int i,k=0;

+   int code, next_code[16], sizes[17];

+

+   // DEFLATE spec for generating codes

+   memset(sizes, 0, sizeof(sizes));

+   memset(z->fast, 0, sizeof(z->fast));

+   for (i=0; i < num; ++i)

+      ++sizes[sizelist[i]];

+   sizes[0] = 0;

+   for (i=1; i < 16; ++i)

+      if (sizes[i] > (1 << i))

+         return stbi__err("bad sizes", "Corrupt PNG");

+   code = 0;

+   for (i=1; i < 16; ++i) {

+      next_code[i] = code;

+      z->firstcode[i] = (stbi__uint16) code;

+      z->firstsymbol[i] = (stbi__uint16) k;

+      code = (code + sizes[i]);

+      if (sizes[i])

+         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");

+      z->maxcode[i] = code << (16-i); // preshift for inner loop

+      code <<= 1;

+      k += sizes[i];

+   }

+   z->maxcode[16] = 0x10000; // sentinel

+   for (i=0; i < num; ++i) {

+      int s = sizelist[i];

+      if (s) {

+         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];

+         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);

+         z->size [c] = (stbi_uc     ) s;

+         z->value[c] = (stbi__uint16) i;

+         if (s <= STBI__ZFAST_BITS) {

+            int j = stbi__bit_reverse(next_code[s],s);

+            while (j < (1 << STBI__ZFAST_BITS)) {

+               z->fast[j] = fastv;

+               j += (1 << s);

+            }

+         }

+         ++next_code[s];

+      }

+   }

+   return 1;

+}

+

+// zlib-from-memory implementation for PNG reading

+//    because PNG allows splitting the zlib stream arbitrarily,

+//    and it's annoying structurally to have PNG call ZLIB call PNG,

+//    we require PNG read all the IDATs and combine them into a single

+//    memory buffer

+

+typedef struct

+{

+   stbi_uc *zbuffer, *zbuffer_end;

+   int num_bits;

+   stbi__uint32 code_buffer;

+

+   char *zout;

+   char *zout_start;

+   char *zout_end;

+   int   z_expandable;

+

+   stbi__zhuffman z_length, z_distance;

+} stbi__zbuf;

+

+stbi_inline static int stbi__zeof(stbi__zbuf *z)

+{

+   return (z->zbuffer >= z->zbuffer_end);

+}

+

+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)

+{

+   return stbi__zeof(z) ? 0 : *z->zbuffer++;

+}

+

+static void stbi__fill_bits(stbi__zbuf *z)

+{

+   do {

+      if (z->code_buffer >= (1U << z->num_bits)) {

+        z->zbuffer = z->zbuffer_end;  /* treat this as EOF so we fail. */

+        return;

+      }

+      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;

+      z->num_bits += 8;

+   } while (z->num_bits <= 24);

+}

+

+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)

+{

+   unsigned int k;

+   if (z->num_bits < n) stbi__fill_bits(z);

+   k = z->code_buffer & ((1 << n) - 1);

+   z->code_buffer >>= n;

+   z->num_bits -= n;

+   return k;

+}

+

+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)

+{

+   int b,s,k;

+   // not resolved by fast table, so compute it the slow way

+   // use jpeg approach, which requires MSbits at top

+   k = stbi__bit_reverse(a->code_buffer, 16);

+   for (s=STBI__ZFAST_BITS+1; ; ++s)

+      if (k < z->maxcode[s])

+         break;

+   if (s >= 16) return -1; // invalid code!

+   // code size is s, so:

+   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];

+   if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!

+   if (z->size[b] != s) return -1;  // was originally an assert, but report failure instead.

+   a->code_buffer >>= s;

+   a->num_bits -= s;

+   return z->value[b];

+}

+

+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)

+{

+   int b,s;

+   if (a->num_bits < 16) {

+      if (stbi__zeof(a)) {

+         return -1;   /* report error for unexpected end of data. */

+      }

+      stbi__fill_bits(a);

+   }

+   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];

+   if (b) {

+      s = b >> 9;

+      a->code_buffer >>= s;

+      a->num_bits -= s;

+      return b & 511;

+   }

+   return stbi__zhuffman_decode_slowpath(a, z);

+}

+

+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes

+{

+   char *q;

+   unsigned int cur, limit, old_limit;

+   z->zout = zout;

+   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");

+   cur   = (unsigned int) (z->zout - z->zout_start);

+   limit = old_limit = (unsigned) (z->zout_end - z->zout_start);

+   if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");

+   while (cur + n > limit) {

+      if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");

+      limit *= 2;

+   }

+   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);

+   STBI_NOTUSED(old_limit);

+   if (q == NULL) return stbi__err("outofmem", "Out of memory");

+   z->zout_start = q;

+   z->zout       = q + cur;

+   z->zout_end   = q + limit;

+   return 1;

+}

+

+static const int stbi__zlength_base[31] = {

+   3,4,5,6,7,8,9,10,11,13,

+   15,17,19,23,27,31,35,43,51,59,

+   67,83,99,115,131,163,195,227,258,0,0 };

+

+static const int stbi__zlength_extra[31]=

+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };

+

+static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,

+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};

+

+static const int stbi__zdist_extra[32] =

+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};

+

+static int stbi__parse_huffman_block(stbi__zbuf *a)

+{

+   char *zout = a->zout;

+   for(;;) {

+      int z = stbi__zhuffman_decode(a, &a->z_length);

+      if (z < 256) {

+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes

+         if (zout >= a->zout_end) {

+            if (!stbi__zexpand(a, zout, 1)) return 0;

+            zout = a->zout;

+         }

+         *zout++ = (char) z;

+      } else {

+         stbi_uc *p;

+         int len,dist;

+         if (z == 256) {

+            a->zout = zout;

+            return 1;

+         }

+         z -= 257;

+         len = stbi__zlength_base[z];

+         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);

+         z = stbi__zhuffman_decode(a, &a->z_distance);

+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG");

+         dist = stbi__zdist_base[z];

+         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);

+         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");

+         if (zout + len > a->zout_end) {

+            if (!stbi__zexpand(a, zout, len)) return 0;

+            zout = a->zout;

+         }

+         p = (stbi_uc *) (zout - dist);

+         if (dist == 1) { // run of one byte; common in images.

+            stbi_uc v = *p;

+            if (len) { do *zout++ = v; while (--len); }

+         } else {

+            if (len) { do *zout++ = *p++; while (--len); }

+         }

+      }

+   }

+}

+

+static int stbi__compute_huffman_codes(stbi__zbuf *a)

+{

+   static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };

+   stbi__zhuffman z_codelength;

+   stbi_uc lencodes[286+32+137];//padding for maximum single op

+   stbi_uc codelength_sizes[19];

+   int i,n;

+

+   int hlit  = stbi__zreceive(a,5) + 257;

+   int hdist = stbi__zreceive(a,5) + 1;

+   int hclen = stbi__zreceive(a,4) + 4;

+   int ntot  = hlit + hdist;

+

+   memset(codelength_sizes, 0, sizeof(codelength_sizes));

+   for (i=0; i < hclen; ++i) {

+      int s = stbi__zreceive(a,3);

+      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;

+   }

+   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;

+

+   n = 0;

+   while (n < ntot) {

+      int c = stbi__zhuffman_decode(a, &z_codelength);

+      if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");

+      if (c < 16)

+         lencodes[n++] = (stbi_uc) c;

+      else {

+         stbi_uc fill = 0;

+         if (c == 16) {

+            c = stbi__zreceive(a,2)+3;

+            if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");

+            fill = lencodes[n-1];

+         } else if (c == 17) {

+            c = stbi__zreceive(a,3)+3;

+         } else if (c == 18) {

+            c = stbi__zreceive(a,7)+11;

+         } else {

+            return stbi__err("bad codelengths", "Corrupt PNG");

+         }

+         if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");

+         memset(lencodes+n, fill, c);

+         n += c;

+      }

+   }

+   if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");

+   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;

+   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;

+   return 1;

+}

+

+static int stbi__parse_uncompressed_block(stbi__zbuf *a)

+{

+   stbi_uc header[4];

+   int len,nlen,k;

+   if (a->num_bits & 7)

+      stbi__zreceive(a, a->num_bits & 7); // discard

+   // drain the bit-packed data into header

+   k = 0;

+   while (a->num_bits > 0) {

+      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check

+      a->code_buffer >>= 8;

+      a->num_bits -= 8;

+   }

+   if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");

+   // now fill header the normal way

+   while (k < 4)

+      header[k++] = stbi__zget8(a);

+   len  = header[1] * 256 + header[0];

+   nlen = header[3] * 256 + header[2];

+   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");

+   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");

+   if (a->zout + len > a->zout_end)

+      if (!stbi__zexpand(a, a->zout, len)) return 0;

+   memcpy(a->zout, a->zbuffer, len);

+   a->zbuffer += len;

+   a->zout += len;

+   return 1;

+}

+

+static int stbi__parse_zlib_header(stbi__zbuf *a)

+{

+   int cmf   = stbi__zget8(a);

+   int cm    = cmf & 15;

+   /* int cinfo = cmf >> 4; */

+   int flg   = stbi__zget8(a);

+   if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec

+   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec

+   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png

+   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png

+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output

+   return 1;

+}

+

+static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =

+{

+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,

+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,

+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,

+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,

+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8

+};

+static const stbi_uc stbi__zdefault_distance[32] =

+{

+   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5

+};

+/*

+Init algorithm:

+{

+   int i;   // use <= to match clearly with spec

+   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;

+   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;

+   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;

+   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;

+

+   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;

+}

+*/

+

+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)

+{

+   int final, type;

+   if (parse_header)

+      if (!stbi__parse_zlib_header(a)) return 0;

+   a->num_bits = 0;

+   a->code_buffer = 0;

+   do {

+      final = stbi__zreceive(a,1);

+      type = stbi__zreceive(a,2);

+      if (type == 0) {

+         if (!stbi__parse_uncompressed_block(a)) return 0;

+      } else if (type == 3) {

+         return 0;

+      } else {

+         if (type == 1) {

+            // use fixed code lengths

+            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , STBI__ZNSYMS)) return 0;

+            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;

+         } else {

+            if (!stbi__compute_huffman_codes(a)) return 0;

+         }

+         if (!stbi__parse_huffman_block(a)) return 0;

+      }

+   } while (!final);

+   return 1;

+}

+

+static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)

+{

+   a->zout_start = obuf;

+   a->zout       = obuf;

+   a->zout_end   = obuf + olen;

+   a->z_expandable = exp;

+

+   return stbi__parse_zlib(a, parse_header);

+}

+

+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)

+{

+   stbi__zbuf a;

+   char *p = (char *) stbi__malloc(initial_size);

+   if (p == NULL) return NULL;

+   a.zbuffer = (stbi_uc *) buffer;

+   a.zbuffer_end = (stbi_uc *) buffer + len;

+   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {

+      if (outlen) *outlen = (int) (a.zout - a.zout_start);

+      return a.zout_start;

+   } else {

+      STBI_FREE(a.zout_start);

+      return NULL;

+   }

+}

+

+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)

+{

+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);

+}

+

+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)

+{

+   stbi__zbuf a;

+   char *p = (char *) stbi__malloc(initial_size);

+   if (p == NULL) return NULL;

+   a.zbuffer = (stbi_uc *) buffer;

+   a.zbuffer_end = (stbi_uc *) buffer + len;

+   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {

+      if (outlen) *outlen = (int) (a.zout - a.zout_start);

+      return a.zout_start;

+   } else {

+      STBI_FREE(a.zout_start);

+      return NULL;

+   }

+}

+

+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)

+{

+   stbi__zbuf a;

+   a.zbuffer = (stbi_uc *) ibuffer;

+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;

+   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))

+      return (int) (a.zout - a.zout_start);

+   else

+      return -1;

+}

+

+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)

+{

+   stbi__zbuf a;

+   char *p = (char *) stbi__malloc(16384);

+   if (p == NULL) return NULL;

+   a.zbuffer = (stbi_uc *) buffer;

+   a.zbuffer_end = (stbi_uc *) buffer+len;

+   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {

+      if (outlen) *outlen = (int) (a.zout - a.zout_start);

+      return a.zout_start;

+   } else {

+      STBI_FREE(a.zout_start);

+      return NULL;

+   }

+}

+

+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)

+{

+   stbi__zbuf a;

+   a.zbuffer = (stbi_uc *) ibuffer;

+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;

+   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))

+      return (int) (a.zout - a.zout_start);

+   else

+      return -1;

+}

+#endif

+

+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18

+//    simple implementation

+//      - only 8-bit samples

+//      - no CRC checking

+//      - allocates lots of intermediate memory

+//        - avoids problem of streaming data between subsystems

+//        - avoids explicit window management

+//    performance

+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding

+

+#ifndef STBI_NO_PNG

+typedef struct

+{

+   stbi__uint32 length;

+   stbi__uint32 type;

+} stbi__pngchunk;

+

+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)

+{

+   stbi__pngchunk c;

+   c.length = stbi__get32be(s);

+   c.type   = stbi__get32be(s);

+   return c;

+}

+

+static int stbi__check_png_header(stbi__context *s)

+{

+   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };

+   int i;

+   for (i=0; i < 8; ++i)

+      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");

+   return 1;

+}

+

+typedef struct

+{

+   stbi__context *s;

+   stbi_uc *idata, *expanded, *out;

+   int depth;

+} stbi__png;

+

+

+enum {

+   STBI__F_none=0,

+   STBI__F_sub=1,

+   STBI__F_up=2,

+   STBI__F_avg=3,

+   STBI__F_paeth=4,

+   // synthetic filters used for first scanline to avoid needing a dummy row of 0s

+   STBI__F_avg_first,

+   STBI__F_paeth_first

+};

+

+static stbi_uc first_row_filter[5] =

+{

+   STBI__F_none,

+   STBI__F_sub,

+   STBI__F_none,

+   STBI__F_avg_first,

+   STBI__F_paeth_first

+};

+

+static int stbi__paeth(int a, int b, int c)

+{

+   int p = a + b - c;

+   int pa = abs(p-a);

+   int pb = abs(p-b);

+   int pc = abs(p-c);

+   if (pa <= pb && pa <= pc) return a;

+   if (pb <= pc) return b;

+   return c;

+}

+

+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };

+

+// create the png data from post-deflated data

+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)

+{

+   int bytes = (depth == 16? 2 : 1);

+   stbi__context *s = a->s;

+   stbi__uint32 i,j,stride = x*out_n*bytes;

+   stbi__uint32 img_len, img_width_bytes;

+   int k;

+   int img_n = s->img_n; // copy it into a local for later

+

+   int output_bytes = out_n*bytes;

+   int filter_bytes = img_n*bytes;

+   int width = x;

+

+   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);

+   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into

+   if (!a->out) return stbi__err("outofmem", "Out of memory");

+

+   if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");

+   img_width_bytes = (((img_n * x * depth) + 7) >> 3);

+   img_len = (img_width_bytes + 1) * y;

+

+   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,

+   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),

+   // so just check for raw_len < img_len always.

+   if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");

+

+   for (j=0; j < y; ++j) {

+      stbi_uc *cur = a->out + stride*j;

+      stbi_uc *prior;

+      int filter = *raw++;

+

+      if (filter > 4)

+         return stbi__err("invalid filter","Corrupt PNG");

+

+      if (depth < 8) {

+         if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG");

+         cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place

+         filter_bytes = 1;

+         width = img_width_bytes;

+      }

+      prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above

+

+      // if first row, use special filter that doesn't sample previous row

+      if (j == 0) filter = first_row_filter[filter];

+

+      // handle first byte explicitly

+      for (k=0; k < filter_bytes; ++k) {

+         switch (filter) {

+            case STBI__F_none       : cur[k] = raw[k]; break;

+            case STBI__F_sub        : cur[k] = raw[k]; break;

+            case STBI__F_up         : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;

+            case STBI__F_avg        : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;

+            case STBI__F_paeth      : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break;

+            case STBI__F_avg_first  : cur[k] = raw[k]; break;

+            case STBI__F_paeth_first: cur[k] = raw[k]; break;

+         }

+      }

+

+      if (depth == 8) {

+         if (img_n != out_n)

+            cur[img_n] = 255; // first pixel

+         raw += img_n;

+         cur += out_n;

+         prior += out_n;

+      } else if (depth == 16) {

+         if (img_n != out_n) {

+            cur[filter_bytes]   = 255; // first pixel top byte

+            cur[filter_bytes+1] = 255; // first pixel bottom byte

+         }

+         raw += filter_bytes;

+         cur += output_bytes;

+         prior += output_bytes;

+      } else {

+         raw += 1;

+         cur += 1;

+         prior += 1;

+      }

+

+      // this is a little gross, so that we don't switch per-pixel or per-component

+      if (depth < 8 || img_n == out_n) {

+         int nk = (width - 1)*filter_bytes;

+         #define STBI__CASE(f) \

+             case f:     \

+                for (k=0; k < nk; ++k)

+         switch (filter) {

+            // "none" filter turns into a memcpy here; make that explicit.

+            case STBI__F_none:         memcpy(cur, raw, nk); break;

+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;

+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;

+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;

+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;

+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;

+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break;

+         }

+         #undef STBI__CASE

+         raw += nk;

+      } else {

+         STBI_ASSERT(img_n+1 == out_n);

+         #define STBI__CASE(f) \

+             case f:     \

+                for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \

+                   for (k=0; k < filter_bytes; ++k)

+         switch (filter) {

+            STBI__CASE(STBI__F_none)         { cur[k] = raw[k]; } break;

+            STBI__CASE(STBI__F_sub)          { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;

+            STBI__CASE(STBI__F_up)           { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;

+            STBI__CASE(STBI__F_avg)          { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;

+            STBI__CASE(STBI__F_paeth)        { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;

+            STBI__CASE(STBI__F_avg_first)    { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;

+            STBI__CASE(STBI__F_paeth_first)  { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break;

+         }

+         #undef STBI__CASE

+

+         // the loop above sets the high byte of the pixels' alpha, but for

+         // 16 bit png files we also need the low byte set. we'll do that here.

+         if (depth == 16) {

+            cur = a->out + stride*j; // start at the beginning of the row again

+            for (i=0; i < x; ++i,cur+=output_bytes) {

+               cur[filter_bytes+1] = 255;

+            }

+         }

+      }

+   }

+

+   // we make a separate pass to expand bits to pixels; for performance,

+   // this could run two scanlines behind the above code, so it won't

+   // intefere with filtering but will still be in the cache.

+   if (depth < 8) {

+      for (j=0; j < y; ++j) {

+         stbi_uc *cur = a->out + stride*j;

+         stbi_uc *in  = a->out + stride*j + x*out_n - img_width_bytes;

+         // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit

+         // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop

+         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range

+

+         // note that the final byte might overshoot and write more data than desired.

+         // we can allocate enough data that this never writes out of memory, but it

+         // could also overwrite the next scanline. can it overwrite non-empty data

+         // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel.

+         // so we need to explicitly clamp the final ones

+

+         if (depth == 4) {

+            for (k=x*img_n; k >= 2; k-=2, ++in) {

+               *cur++ = scale * ((*in >> 4)       );

+               *cur++ = scale * ((*in     ) & 0x0f);

+            }

+            if (k > 0) *cur++ = scale * ((*in >> 4)       );

+         } else if (depth == 2) {

+            for (k=x*img_n; k >= 4; k-=4, ++in) {

+               *cur++ = scale * ((*in >> 6)       );

+               *cur++ = scale * ((*in >> 4) & 0x03);

+               *cur++ = scale * ((*in >> 2) & 0x03);

+               *cur++ = scale * ((*in     ) & 0x03);

+            }

+            if (k > 0) *cur++ = scale * ((*in >> 6)       );

+            if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);

+            if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);

+         } else if (depth == 1) {

+            for (k=x*img_n; k >= 8; k-=8, ++in) {

+               *cur++ = scale * ((*in >> 7)       );

+               *cur++ = scale * ((*in >> 6) & 0x01);

+               *cur++ = scale * ((*in >> 5) & 0x01);

+               *cur++ = scale * ((*in >> 4) & 0x01);

+               *cur++ = scale * ((*in >> 3) & 0x01);

+               *cur++ = scale * ((*in >> 2) & 0x01);

+               *cur++ = scale * ((*in >> 1) & 0x01);

+               *cur++ = scale * ((*in     ) & 0x01);

+            }

+            if (k > 0) *cur++ = scale * ((*in >> 7)       );

+            if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);

+            if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);

+            if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);

+            if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);

+            if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);

+            if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);

+         }

+         if (img_n != out_n) {

+            int q;

+            // insert alpha = 255

+            cur = a->out + stride*j;

+            if (img_n == 1) {

+               for (q=x-1; q >= 0; --q) {

+                  cur[q*2+1] = 255;

+                  cur[q*2+0] = cur[q];

+               }

+            } else {

+               STBI_ASSERT(img_n == 3);

+               for (q=x-1; q >= 0; --q) {

+                  cur[q*4+3] = 255;

+                  cur[q*4+2] = cur[q*3+2];

+                  cur[q*4+1] = cur[q*3+1];

+                  cur[q*4+0] = cur[q*3+0];

+               }

+            }

+         }

+      }

+   } else if (depth == 16) {

+      // force the image data from big-endian to platform-native.

+      // this is done in a separate pass due to the decoding relying

+      // on the data being untouched, but could probably be done

+      // per-line during decode if care is taken.

+      stbi_uc *cur = a->out;

+      stbi__uint16 *cur16 = (stbi__uint16*)cur;

+

+      for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {

+         *cur16 = (cur[0] << 8) | cur[1];

+      }

+   }

+

+   return 1;

+}

+

+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)

+{

+   int bytes = (depth == 16 ? 2 : 1);

+   int out_bytes = out_n * bytes;

+   stbi_uc *final;

+   int p;

+   if (!interlaced)

+      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);

+

+   // de-interlacing

+   final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);

+   if (!final) return stbi__err("outofmem", "Out of memory");

+   for (p=0; p < 7; ++p) {

+      int xorig[] = { 0,4,0,2,0,1,0 };

+      int yorig[] = { 0,0,4,0,2,0,1 };

+      int xspc[]  = { 8,8,4,4,2,2,1 };

+      int yspc[]  = { 8,8,8,4,4,2,2 };

+      int i,j,x,y;

+      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1

+      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];

+      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];

+      if (x && y) {

+         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;

+         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {

+            STBI_FREE(final);

+            return 0;

+         }

+         for (j=0; j < y; ++j) {

+            for (i=0; i < x; ++i) {

+               int out_y = j*yspc[p]+yorig[p];

+               int out_x = i*xspc[p]+xorig[p];

+               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,

+                      a->out + (j*x+i)*out_bytes, out_bytes);

+            }

+         }

+         STBI_FREE(a->out);

+         image_data += img_len;

+         image_data_len -= img_len;

+      }

+   }

+   a->out = final;

+

+   return 1;

+}

+

+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)

+{

+   stbi__context *s = z->s;

+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;

+   stbi_uc *p = z->out;

+

+   // compute color-based transparency, assuming we've

+   // already got 255 as the alpha value in the output

+   STBI_ASSERT(out_n == 2 || out_n == 4);

+

+   if (out_n == 2) {

+      for (i=0; i < pixel_count; ++i) {

+         p[1] = (p[0] == tc[0] ? 0 : 255);

+         p += 2;

+      }

+   } else {

+      for (i=0; i < pixel_count; ++i) {

+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])

+            p[3] = 0;

+         p += 4;

+      }

+   }

+   return 1;

+}

+

+static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)

+{

+   stbi__context *s = z->s;

+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;

+   stbi__uint16 *p = (stbi__uint16*) z->out;

+

+   // compute color-based transparency, assuming we've

+   // already got 65535 as the alpha value in the output

+   STBI_ASSERT(out_n == 2 || out_n == 4);

+

+   if (out_n == 2) {

+      for (i = 0; i < pixel_count; ++i) {

+         p[1] = (p[0] == tc[0] ? 0 : 65535);

+         p += 2;

+      }

+   } else {

+      for (i = 0; i < pixel_count; ++i) {

+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])

+            p[3] = 0;

+         p += 4;

+      }

+   }

+   return 1;

+}

+

+static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)

+{

+   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;

+   stbi_uc *p, *temp_out, *orig = a->out;

+

+   p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);

+   if (p == NULL) return stbi__err("outofmem", "Out of memory");

+

+   // between here and free(out) below, exitting would leak

+   temp_out = p;

+

+   if (pal_img_n == 3) {

+      for (i=0; i < pixel_count; ++i) {

+         int n = orig[i]*4;

+         p[0] = palette[n  ];

+         p[1] = palette[n+1];

+         p[2] = palette[n+2];

+         p += 3;

+      }

+   } else {

+      for (i=0; i < pixel_count; ++i) {

+         int n = orig[i]*4;

+         p[0] = palette[n  ];

+         p[1] = palette[n+1];

+         p[2] = palette[n+2];

+         p[3] = palette[n+3];

+         p += 4;

+      }

+   }

+   STBI_FREE(a->out);

+   a->out = temp_out;

+

+   STBI_NOTUSED(len);

+

+   return 1;

+}

+

+static int stbi__unpremultiply_on_load_global = 0;

+static int stbi__de_iphone_flag_global = 0;

+

+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)

+{

+   stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;

+}

+

+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)

+{

+   stbi__de_iphone_flag_global = flag_true_if_should_convert;

+}

+

+#ifndef STBI_THREAD_LOCAL

+#define stbi__unpremultiply_on_load  stbi__unpremultiply_on_load_global

+#define stbi__de_iphone_flag  stbi__de_iphone_flag_global

+#else

+static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;

+static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;

+

+STBIDEF void stbi__unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)

+{

+   stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;

+   stbi__unpremultiply_on_load_set = 1;

+}

+

+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)

+{

+   stbi__de_iphone_flag_local = flag_true_if_should_convert;

+   stbi__de_iphone_flag_set = 1;

+}

+

+#define stbi__unpremultiply_on_load  (stbi__unpremultiply_on_load_set           \

+                                       ? stbi__unpremultiply_on_load_local      \

+                                       : stbi__unpremultiply_on_load_global)

+#define stbi__de_iphone_flag  (stbi__de_iphone_flag_set                         \

+                                ? stbi__de_iphone_flag_local                    \

+                                : stbi__de_iphone_flag_global)

+#endif // STBI_THREAD_LOCAL

+

+static void stbi__de_iphone(stbi__png *z)

+{

+   stbi__context *s = z->s;

+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;

+   stbi_uc *p = z->out;

+

+   if (s->img_out_n == 3) {  // convert bgr to rgb

+      for (i=0; i < pixel_count; ++i) {

+         stbi_uc t = p[0];

+         p[0] = p[2];

+         p[2] = t;

+         p += 3;

+      }

+   } else {

+      STBI_ASSERT(s->img_out_n == 4);

+      if (stbi__unpremultiply_on_load) {

+         // convert bgr to rgb and unpremultiply

+         for (i=0; i < pixel_count; ++i) {

+            stbi_uc a = p[3];

+            stbi_uc t = p[0];

+            if (a) {

+               stbi_uc half = a / 2;

+               p[0] = (p[2] * 255 + half) / a;

+               p[1] = (p[1] * 255 + half) / a;

+               p[2] = ( t   * 255 + half) / a;

+            } else {

+               p[0] = p[2];

+               p[2] = t;

+            }

+            p += 4;

+         }

+      } else {

+         // convert bgr to rgb

+         for (i=0; i < pixel_count; ++i) {

+            stbi_uc t = p[0];

+            p[0] = p[2];

+            p[2] = t;

+            p += 4;

+         }

+      }

+   }

+}

+

+#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))

+

+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)

+{

+   stbi_uc palette[1024], pal_img_n=0;

+   stbi_uc has_trans=0, tc[3]={0};

+   stbi__uint16 tc16[3];

+   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;

+   int first=1,k,interlace=0, color=0, is_iphone=0;

+   stbi__context *s = z->s;

+

+   z->expanded = NULL;

+   z->idata = NULL;

+   z->out = NULL;

+

+   if (!stbi__check_png_header(s)) return 0;

+

+   if (scan == STBI__SCAN_type) return 1;

+

+   for (;;) {

+      stbi__pngchunk c = stbi__get_chunk_header(s);

+      switch (c.type) {

+         case STBI__PNG_TYPE('C','g','B','I'):

+            is_iphone = 1;

+            stbi__skip(s, c.length);

+            break;

+         case STBI__PNG_TYPE('I','H','D','R'): {

+            int comp,filter;

+            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");

+            first = 0;

+            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");

+            s->img_x = stbi__get32be(s);

+            s->img_y = stbi__get32be(s);

+            if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");

+            if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");

+            z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");

+            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");

+            if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");

+            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");

+            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");

+            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");

+            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");

+            if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");

+            if (!pal_img_n) {

+               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);

+               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");

+               if (scan == STBI__SCAN_header) return 1;

+            } else {

+               // if paletted, then pal_n is our final components, and

+               // img_n is # components to decompress/filter.

+               s->img_n = 1;

+               if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");

+               // if SCAN_header, have to scan to see if we have a tRNS

+            }

+            break;

+         }

+

+         case STBI__PNG_TYPE('P','L','T','E'):  {

+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");

+            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");

+            pal_len = c.length / 3;

+            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");

+            for (i=0; i < pal_len; ++i) {

+               palette[i*4+0] = stbi__get8(s);

+               palette[i*4+1] = stbi__get8(s);

+               palette[i*4+2] = stbi__get8(s);

+               palette[i*4+3] = 255;

+            }

+            break;

+         }

+

+         case STBI__PNG_TYPE('t','R','N','S'): {

+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");

+            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");

+            if (pal_img_n) {

+               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }

+               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");

+               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");

+               pal_img_n = 4;

+               for (i=0; i < c.length; ++i)

+                  palette[i*4+3] = stbi__get8(s);

+            } else {

+               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");

+               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");

+               has_trans = 1;

+               if (z->depth == 16) {

+                  for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is

+               } else {

+                  for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger

+               }

+            }

+            break;

+         }

+

+         case STBI__PNG_TYPE('I','D','A','T'): {

+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");

+            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");

+            if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }

+            if ((int)(ioff + c.length) < (int)ioff) return 0;

+            if (ioff + c.length > idata_limit) {

+               stbi__uint32 idata_limit_old = idata_limit;

+               stbi_uc *p;

+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;

+               while (ioff + c.length > idata_limit)

+                  idata_limit *= 2;

+               STBI_NOTUSED(idata_limit_old);

+               p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");

+               z->idata = p;

+            }

+            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");

+            ioff += c.length;

+            break;

+         }

+

+         case STBI__PNG_TYPE('I','E','N','D'): {

+            stbi__uint32 raw_len, bpl;

+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");

+            if (scan != STBI__SCAN_load) return 1;

+            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");

+            // initial guess for decoded data size to avoid unnecessary reallocs

+            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component

+            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;

+            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);

+            if (z->expanded == NULL) return 0; // zlib should set error

+            STBI_FREE(z->idata); z->idata = NULL;

+            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)

+               s->img_out_n = s->img_n+1;

+            else

+               s->img_out_n = s->img_n;

+            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;

+            if (has_trans) {

+               if (z->depth == 16) {

+                  if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;

+               } else {

+                  if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;

+               }

+            }

+            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)

+               stbi__de_iphone(z);

+            if (pal_img_n) {

+               // pal_img_n == 3 or 4

+               s->img_n = pal_img_n; // record the actual colors we had

+               s->img_out_n = pal_img_n;

+               if (req_comp >= 3) s->img_out_n = req_comp;

+               if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))

+                  return 0;

+            } else if (has_trans) {

+               // non-paletted image with tRNS -> source image has (constant) alpha

+               ++s->img_n;

+            }

+            STBI_FREE(z->expanded); z->expanded = NULL;

+            // end of PNG chunk, read and skip CRC

+            stbi__get32be(s);

+            return 1;

+         }

+

+         default:

+            // if critical, fail

+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");

+            if ((c.type & (1 << 29)) == 0) {

+               #ifndef STBI_NO_FAILURE_STRINGS

+               // not threadsafe

+               static char invalid_chunk[] = "XXXX PNG chunk not known";

+               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);

+               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);

+               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);

+               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);

+               #endif

+               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");

+            }

+            stbi__skip(s, c.length);

+            break;

+      }

+      // end of PNG chunk, read and skip CRC

+      stbi__get32be(s);

+   }

+}

+

+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)

+{

+   void *result=NULL;

+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");

+   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {

+      if (p->depth <= 8)

+         ri->bits_per_channel = 8;

+      else if (p->depth == 16)

+         ri->bits_per_channel = 16;

+      else

+         return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");

+      result = p->out;

+      p->out = NULL;

+      if (req_comp && req_comp != p->s->img_out_n) {

+         if (ri->bits_per_channel == 8)

+            result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);

+         else

+            result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);

+         p->s->img_out_n = req_comp;

+         if (result == NULL) return result;

+      }

+      *x = p->s->img_x;

+      *y = p->s->img_y;

+      if (n) *n = p->s->img_n;

+   }

+   STBI_FREE(p->out);      p->out      = NULL;

+   STBI_FREE(p->expanded); p->expanded = NULL;

+   STBI_FREE(p->idata);    p->idata    = NULL;

+

+   return result;

+}

+

+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)

+{

+   stbi__png p;

+   p.s = s;

+   return stbi__do_png(&p, x,y,comp,req_comp, ri);

+}

+

+static int stbi__png_test(stbi__context *s)

+{

+   int r;

+   r = stbi__check_png_header(s);

+   stbi__rewind(s);

+   return r;

+}

+

+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)

+{

+   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {

+      stbi__rewind( p->s );

+      return 0;

+   }

+   if (x) *x = p->s->img_x;

+   if (y) *y = p->s->img_y;

+   if (comp) *comp = p->s->img_n;

+   return 1;

+}

+

+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   stbi__png p;

+   p.s = s;

+   return stbi__png_info_raw(&p, x, y, comp);

+}

+

+static int stbi__png_is16(stbi__context *s)

+{

+   stbi__png p;

+   p.s = s;

+   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))

+	   return 0;

+   if (p.depth != 16) {

+      stbi__rewind(p.s);

+      return 0;

+   }

+   return 1;

+}

+#endif

+

+// Microsoft/Windows BMP image

+

+#ifndef STBI_NO_BMP

+static int stbi__bmp_test_raw(stbi__context *s)

+{

+   int r;

+   int sz;

+   if (stbi__get8(s) != 'B') return 0;

+   if (stbi__get8(s) != 'M') return 0;

+   stbi__get32le(s); // discard filesize

+   stbi__get16le(s); // discard reserved

+   stbi__get16le(s); // discard reserved

+   stbi__get32le(s); // discard data offset

+   sz = stbi__get32le(s);

+   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);

+   return r;

+}

+

+static int stbi__bmp_test(stbi__context *s)

+{

+   int r = stbi__bmp_test_raw(s);

+   stbi__rewind(s);

+   return r;

+}

+

+

+// returns 0..31 for the highest set bit

+static int stbi__high_bit(unsigned int z)

+{

+   int n=0;

+   if (z == 0) return -1;

+   if (z >= 0x10000) { n += 16; z >>= 16; }

+   if (z >= 0x00100) { n +=  8; z >>=  8; }

+   if (z >= 0x00010) { n +=  4; z >>=  4; }

+   if (z >= 0x00004) { n +=  2; z >>=  2; }

+   if (z >= 0x00002) { n +=  1;/* >>=  1;*/ }

+   return n;

+}

+

+static int stbi__bitcount(unsigned int a)

+{

+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2

+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4

+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits

+   a = (a + (a >> 8)); // max 16 per 8 bits

+   a = (a + (a >> 16)); // max 32 per 8 bits

+   return a & 0xff;

+}

+

+// extract an arbitrarily-aligned N-bit value (N=bits)

+// from v, and then make it 8-bits long and fractionally

+// extend it to full full range.

+static int stbi__shiftsigned(unsigned int v, int shift, int bits)

+{

+   static unsigned int mul_table[9] = {

+      0,

+      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,

+      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,

+   };

+   static unsigned int shift_table[9] = {

+      0, 0,0,1,0,2,4,6,0,

+   };

+   if (shift < 0)

+      v <<= -shift;

+   else

+      v >>= shift;

+   STBI_ASSERT(v < 256);

+   v >>= (8-bits);

+   STBI_ASSERT(bits >= 0 && bits <= 8);

+   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];

+}

+

+typedef struct

+{

+   int bpp, offset, hsz;

+   unsigned int mr,mg,mb,ma, all_a;

+   int extra_read;

+} stbi__bmp_data;

+

+static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)

+{

+   // BI_BITFIELDS specifies masks explicitly, don't override

+   if (compress == 3)

+      return 1;

+

+   if (compress == 0) {

+      if (info->bpp == 16) {

+         info->mr = 31u << 10;

+         info->mg = 31u <<  5;

+         info->mb = 31u <<  0;

+      } else if (info->bpp == 32) {

+         info->mr = 0xffu << 16;

+         info->mg = 0xffu <<  8;

+         info->mb = 0xffu <<  0;

+         info->ma = 0xffu << 24;

+         info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0

+      } else {

+         // otherwise, use defaults, which is all-0

+         info->mr = info->mg = info->mb = info->ma = 0;

+      }

+      return 1;

+   }

+   return 0; // error

+}

+

+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)

+{

+   int hsz;

+   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");

+   stbi__get32le(s); // discard filesize

+   stbi__get16le(s); // discard reserved

+   stbi__get16le(s); // discard reserved

+   info->offset = stbi__get32le(s);

+   info->hsz = hsz = stbi__get32le(s);

+   info->mr = info->mg = info->mb = info->ma = 0;

+   info->extra_read = 14;

+

+   if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");

+

+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");

+   if (hsz == 12) {

+      s->img_x = stbi__get16le(s);

+      s->img_y = stbi__get16le(s);

+   } else {

+      s->img_x = stbi__get32le(s);

+      s->img_y = stbi__get32le(s);

+   }

+   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");

+   info->bpp = stbi__get16le(s);

+   if (hsz != 12) {

+      int compress = stbi__get32le(s);

+      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");

+      if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes

+      if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel

+      stbi__get32le(s); // discard sizeof

+      stbi__get32le(s); // discard hres

+      stbi__get32le(s); // discard vres

+      stbi__get32le(s); // discard colorsused

+      stbi__get32le(s); // discard max important

+      if (hsz == 40 || hsz == 56) {

+         if (hsz == 56) {

+            stbi__get32le(s);

+            stbi__get32le(s);

+            stbi__get32le(s);

+            stbi__get32le(s);

+         }

+         if (info->bpp == 16 || info->bpp == 32) {

+            if (compress == 0) {

+               stbi__bmp_set_mask_defaults(info, compress);

+            } else if (compress == 3) {

+               info->mr = stbi__get32le(s);

+               info->mg = stbi__get32le(s);

+               info->mb = stbi__get32le(s);

+               info->extra_read += 12;

+               // not documented, but generated by photoshop and handled by mspaint

+               if (info->mr == info->mg && info->mg == info->mb) {

+                  // ?!?!?

+                  return stbi__errpuc("bad BMP", "bad BMP");

+               }

+            } else

+               return stbi__errpuc("bad BMP", "bad BMP");

+         }

+      } else {

+         // V4/V5 header

+         int i;

+         if (hsz != 108 && hsz != 124)

+            return stbi__errpuc("bad BMP", "bad BMP");

+         info->mr = stbi__get32le(s);

+         info->mg = stbi__get32le(s);

+         info->mb = stbi__get32le(s);

+         info->ma = stbi__get32le(s);

+         if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs

+            stbi__bmp_set_mask_defaults(info, compress);

+         stbi__get32le(s); // discard color space

+         for (i=0; i < 12; ++i)

+            stbi__get32le(s); // discard color space parameters

+         if (hsz == 124) {

+            stbi__get32le(s); // discard rendering intent

+            stbi__get32le(s); // discard offset of profile data

+            stbi__get32le(s); // discard size of profile data

+            stbi__get32le(s); // discard reserved

+         }

+      }

+   }

+   return (void *) 1;

+}

+

+

+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)

+{

+   stbi_uc *out;

+   unsigned int mr=0,mg=0,mb=0,ma=0, all_a;

+   stbi_uc pal[256][4];

+   int psize=0,i,j,width;

+   int flip_vertically, pad, target;

+   stbi__bmp_data info;

+   STBI_NOTUSED(ri);

+

+   info.all_a = 255;

+   if (stbi__bmp_parse_header(s, &info) == NULL)

+      return NULL; // error code already set

+

+   flip_vertically = ((int) s->img_y) > 0;

+   s->img_y = abs((int) s->img_y);

+

+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+

+   mr = info.mr;

+   mg = info.mg;

+   mb = info.mb;

+   ma = info.ma;

+   all_a = info.all_a;

+

+   if (info.hsz == 12) {

+      if (info.bpp < 24)

+         psize = (info.offset - info.extra_read - 24) / 3;

+   } else {

+      if (info.bpp < 16)

+         psize = (info.offset - info.extra_read - info.hsz) >> 2;

+   }

+   if (psize == 0) {

+      if (info.offset != s->callback_already_read + (s->img_buffer - s->img_buffer_original)) {

+        return stbi__errpuc("bad offset", "Corrupt BMP");

+      }

+   }

+

+   if (info.bpp == 24 && ma == 0xff000000)

+      s->img_n = 3;

+   else

+      s->img_n = ma ? 4 : 3;

+   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4

+      target = req_comp;

+   else

+      target = s->img_n; // if they want monochrome, we'll post-convert

+

+   // sanity-check size

+   if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))

+      return stbi__errpuc("too large", "Corrupt BMP");

+

+   out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);

+   if (!out) return stbi__errpuc("outofmem", "Out of memory");

+   if (info.bpp < 16) {

+      int z=0;

+      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }

+      for (i=0; i < psize; ++i) {

+         pal[i][2] = stbi__get8(s);

+         pal[i][1] = stbi__get8(s);

+         pal[i][0] = stbi__get8(s);

+         if (info.hsz != 12) stbi__get8(s);

+         pal[i][3] = 255;

+      }

+      stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));

+      if (info.bpp == 1) width = (s->img_x + 7) >> 3;

+      else if (info.bpp == 4) width = (s->img_x + 1) >> 1;

+      else if (info.bpp == 8) width = s->img_x;

+      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }

+      pad = (-width)&3;

+      if (info.bpp == 1) {

+         for (j=0; j < (int) s->img_y; ++j) {

+            int bit_offset = 7, v = stbi__get8(s);

+            for (i=0; i < (int) s->img_x; ++i) {

+               int color = (v>>bit_offset)&0x1;

+               out[z++] = pal[color][0];

+               out[z++] = pal[color][1];

+               out[z++] = pal[color][2];

+               if (target == 4) out[z++] = 255;

+               if (i+1 == (int) s->img_x) break;

+               if((--bit_offset) < 0) {

+                  bit_offset = 7;

+                  v = stbi__get8(s);

+               }

+            }

+            stbi__skip(s, pad);

+         }

+      } else {

+         for (j=0; j < (int) s->img_y; ++j) {

+            for (i=0; i < (int) s->img_x; i += 2) {

+               int v=stbi__get8(s),v2=0;

+               if (info.bpp == 4) {

+                  v2 = v & 15;

+                  v >>= 4;

+               }

+               out[z++] = pal[v][0];

+               out[z++] = pal[v][1];

+               out[z++] = pal[v][2];

+               if (target == 4) out[z++] = 255;

+               if (i+1 == (int) s->img_x) break;

+               v = (info.bpp == 8) ? stbi__get8(s) : v2;

+               out[z++] = pal[v][0];

+               out[z++] = pal[v][1];

+               out[z++] = pal[v][2];

+               if (target == 4) out[z++] = 255;

+            }

+            stbi__skip(s, pad);

+         }

+      }

+   } else {

+      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;

+      int z = 0;

+      int easy=0;

+      stbi__skip(s, info.offset - info.extra_read - info.hsz);

+      if (info.bpp == 24) width = 3 * s->img_x;

+      else if (info.bpp == 16) width = 2*s->img_x;

+      else /* bpp = 32 and pad = 0 */ width=0;

+      pad = (-width) & 3;

+      if (info.bpp == 24) {

+         easy = 1;

+      } else if (info.bpp == 32) {

+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)

+            easy = 2;

+      }

+      if (!easy) {

+         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }

+         // right shift amt to put high bit in position #7

+         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);

+         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);

+         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);

+         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);

+         if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }

+      }

+      for (j=0; j < (int) s->img_y; ++j) {

+         if (easy) {

+            for (i=0; i < (int) s->img_x; ++i) {

+               unsigned char a;

+               out[z+2] = stbi__get8(s);

+               out[z+1] = stbi__get8(s);

+               out[z+0] = stbi__get8(s);

+               z += 3;

+               a = (easy == 2 ? stbi__get8(s) : 255);

+               all_a |= a;

+               if (target == 4) out[z++] = a;

+            }

+         } else {

+            int bpp = info.bpp;

+            for (i=0; i < (int) s->img_x; ++i) {

+               stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));

+               unsigned int a;

+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));

+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));

+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));

+               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);

+               all_a |= a;

+               if (target == 4) out[z++] = STBI__BYTECAST(a);

+            }

+         }

+         stbi__skip(s, pad);

+      }

+   }

+

+   // if alpha channel is all 0s, replace with all 255s

+   if (target == 4 && all_a == 0)

+      for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)

+         out[i] = 255;

+

+   if (flip_vertically) {

+      stbi_uc t;

+      for (j=0; j < (int) s->img_y>>1; ++j) {

+         stbi_uc *p1 = out +      j     *s->img_x*target;

+         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;

+         for (i=0; i < (int) s->img_x*target; ++i) {

+            t = p1[i]; p1[i] = p2[i]; p2[i] = t;

+         }

+      }

+   }

+

+   if (req_comp && req_comp != target) {

+      out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);

+      if (out == NULL) return out; // stbi__convert_format frees input on failure

+   }

+

+   *x = s->img_x;

+   *y = s->img_y;

+   if (comp) *comp = s->img_n;

+   return out;

+}

+#endif

+

+// Targa Truevision - TGA

+// by Jonathan Dummer

+#ifndef STBI_NO_TGA

+// returns STBI_rgb or whatever, 0 on error

+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)

+{

+   // only RGB or RGBA (incl. 16bit) or grey allowed

+   if (is_rgb16) *is_rgb16 = 0;

+   switch(bits_per_pixel) {

+      case 8:  return STBI_grey;

+      case 16: if(is_grey) return STBI_grey_alpha;

+               // fallthrough

+      case 15: if(is_rgb16) *is_rgb16 = 1;

+               return STBI_rgb;

+      case 24: // fallthrough

+      case 32: return bits_per_pixel/8;

+      default: return 0;

+   }

+}

+

+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)

+{

+    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;

+    int sz, tga_colormap_type;

+    stbi__get8(s);                   // discard Offset

+    tga_colormap_type = stbi__get8(s); // colormap type

+    if( tga_colormap_type > 1 ) {

+        stbi__rewind(s);

+        return 0;      // only RGB or indexed allowed

+    }

+    tga_image_type = stbi__get8(s); // image type

+    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image

+        if (tga_image_type != 1 && tga_image_type != 9) {

+            stbi__rewind(s);

+            return 0;

+        }

+        stbi__skip(s,4);       // skip index of first colormap entry and number of entries

+        sz = stbi__get8(s);    //   check bits per palette color entry

+        if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {

+            stbi__rewind(s);

+            return 0;

+        }

+        stbi__skip(s,4);       // skip image x and y origin

+        tga_colormap_bpp = sz;

+    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE

+        if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {

+            stbi__rewind(s);

+            return 0; // only RGB or grey allowed, +/- RLE

+        }

+        stbi__skip(s,9); // skip colormap specification and image x/y origin

+        tga_colormap_bpp = 0;

+    }

+    tga_w = stbi__get16le(s);

+    if( tga_w < 1 ) {

+        stbi__rewind(s);

+        return 0;   // test width

+    }

+    tga_h = stbi__get16le(s);

+    if( tga_h < 1 ) {

+        stbi__rewind(s);

+        return 0;   // test height

+    }

+    tga_bits_per_pixel = stbi__get8(s); // bits per pixel

+    stbi__get8(s); // ignore alpha bits

+    if (tga_colormap_bpp != 0) {

+        if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {

+            // when using a colormap, tga_bits_per_pixel is the size of the indexes

+            // I don't think anything but 8 or 16bit indexes makes sense

+            stbi__rewind(s);

+            return 0;

+        }

+        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);

+    } else {

+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);

+    }

+    if(!tga_comp) {

+      stbi__rewind(s);

+      return 0;

+    }

+    if (x) *x = tga_w;

+    if (y) *y = tga_h;

+    if (comp) *comp = tga_comp;

+    return 1;                   // seems to have passed everything

+}

+

+static int stbi__tga_test(stbi__context *s)

+{

+   int res = 0;

+   int sz, tga_color_type;

+   stbi__get8(s);      //   discard Offset

+   tga_color_type = stbi__get8(s);   //   color type

+   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed

+   sz = stbi__get8(s);   //   image type

+   if ( tga_color_type == 1 ) { // colormapped (paletted) image

+      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9

+      stbi__skip(s,4);       // skip index of first colormap entry and number of entries

+      sz = stbi__get8(s);    //   check bits per palette color entry

+      if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;

+      stbi__skip(s,4);       // skip image x and y origin

+   } else { // "normal" image w/o colormap

+      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE

+      stbi__skip(s,9); // skip colormap specification and image x/y origin

+   }

+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width

+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height

+   sz = stbi__get8(s);   //   bits per pixel

+   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index

+   if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;

+

+   res = 1; // if we got this far, everything's good and we can return 1 instead of 0

+

+errorEnd:

+   stbi__rewind(s);

+   return res;

+}

+

+// read 16bit value and convert to 24bit RGB

+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)

+{

+   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);

+   stbi__uint16 fiveBitMask = 31;

+   // we have 3 channels with 5bits each

+   int r = (px >> 10) & fiveBitMask;

+   int g = (px >> 5) & fiveBitMask;

+   int b = px & fiveBitMask;

+   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later

+   out[0] = (stbi_uc)((r * 255)/31);

+   out[1] = (stbi_uc)((g * 255)/31);

+   out[2] = (stbi_uc)((b * 255)/31);

+

+   // some people claim that the most significant bit might be used for alpha

+   // (possibly if an alpha-bit is set in the "image descriptor byte")

+   // but that only made 16bit test images completely translucent..

+   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.

+}

+

+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)

+{

+   //   read in the TGA header stuff

+   int tga_offset = stbi__get8(s);

+   int tga_indexed = stbi__get8(s);

+   int tga_image_type = stbi__get8(s);

+   int tga_is_RLE = 0;

+   int tga_palette_start = stbi__get16le(s);

+   int tga_palette_len = stbi__get16le(s);

+   int tga_palette_bits = stbi__get8(s);

+   int tga_x_origin = stbi__get16le(s);

+   int tga_y_origin = stbi__get16le(s);

+   int tga_width = stbi__get16le(s);

+   int tga_height = stbi__get16le(s);

+   int tga_bits_per_pixel = stbi__get8(s);

+   int tga_comp, tga_rgb16=0;

+   int tga_inverted = stbi__get8(s);

+   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)

+   //   image data

+   unsigned char *tga_data;

+   unsigned char *tga_palette = NULL;

+   int i, j;

+   unsigned char raw_data[4] = {0};

+   int RLE_count = 0;

+   int RLE_repeating = 0;

+   int read_next_pixel = 1;

+   STBI_NOTUSED(ri);

+   STBI_NOTUSED(tga_x_origin); // @TODO

+   STBI_NOTUSED(tga_y_origin); // @TODO

+

+   if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+   if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+

+   //   do a tiny bit of precessing

+   if ( tga_image_type >= 8 )

+   {

+      tga_image_type -= 8;

+      tga_is_RLE = 1;

+   }

+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);

+

+   //   If I'm paletted, then I'll use the number of bits from the palette

+   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);

+   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);

+

+   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency

+      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");

+

+   //   tga info

+   *x = tga_width;

+   *y = tga_height;

+   if (comp) *comp = tga_comp;

+

+   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))

+      return stbi__errpuc("too large", "Corrupt TGA");

+

+   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);

+   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");

+

+   // skip to the data's starting position (offset usually = 0)

+   stbi__skip(s, tga_offset );

+

+   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {

+      for (i=0; i < tga_height; ++i) {

+         int row = tga_inverted ? tga_height -i - 1 : i;

+         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;

+         stbi__getn(s, tga_row, tga_width * tga_comp);

+      }

+   } else  {

+      //   do I need to load a palette?

+      if ( tga_indexed)

+      {

+         if (tga_palette_len == 0) {  /* you have to have at least one entry! */

+            STBI_FREE(tga_data);

+            return stbi__errpuc("bad palette", "Corrupt TGA");

+         }

+

+         //   any data to skip? (offset usually = 0)

+         stbi__skip(s, tga_palette_start );

+         //   load the palette

+         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);

+         if (!tga_palette) {

+            STBI_FREE(tga_data);

+            return stbi__errpuc("outofmem", "Out of memory");

+         }

+         if (tga_rgb16) {

+            stbi_uc *pal_entry = tga_palette;

+            STBI_ASSERT(tga_comp == STBI_rgb);

+            for (i=0; i < tga_palette_len; ++i) {

+               stbi__tga_read_rgb16(s, pal_entry);

+               pal_entry += tga_comp;

+            }

+         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {

+               STBI_FREE(tga_data);

+               STBI_FREE(tga_palette);

+               return stbi__errpuc("bad palette", "Corrupt TGA");

+         }

+      }

+      //   load the data

+      for (i=0; i < tga_width * tga_height; ++i)

+      {

+         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?

+         if ( tga_is_RLE )

+         {

+            if ( RLE_count == 0 )

+            {

+               //   yep, get the next byte as a RLE command

+               int RLE_cmd = stbi__get8(s);

+               RLE_count = 1 + (RLE_cmd & 127);

+               RLE_repeating = RLE_cmd >> 7;

+               read_next_pixel = 1;

+            } else if ( !RLE_repeating )

+            {

+               read_next_pixel = 1;

+            }

+         } else

+         {

+            read_next_pixel = 1;

+         }

+         //   OK, if I need to read a pixel, do it now

+         if ( read_next_pixel )

+         {

+            //   load however much data we did have

+            if ( tga_indexed )

+            {

+               // read in index, then perform the lookup

+               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);

+               if ( pal_idx >= tga_palette_len ) {

+                  // invalid index

+                  pal_idx = 0;

+               }

+               pal_idx *= tga_comp;

+               for (j = 0; j < tga_comp; ++j) {

+                  raw_data[j] = tga_palette[pal_idx+j];

+               }

+            } else if(tga_rgb16) {

+               STBI_ASSERT(tga_comp == STBI_rgb);

+               stbi__tga_read_rgb16(s, raw_data);

+            } else {

+               //   read in the data raw

+               for (j = 0; j < tga_comp; ++j) {

+                  raw_data[j] = stbi__get8(s);

+               }

+            }

+            //   clear the reading flag for the next pixel

+            read_next_pixel = 0;

+         } // end of reading a pixel

+

+         // copy data

+         for (j = 0; j < tga_comp; ++j)

+           tga_data[i*tga_comp+j] = raw_data[j];

+

+         //   in case we're in RLE mode, keep counting down

+         --RLE_count;

+      }

+      //   do I need to invert the image?

+      if ( tga_inverted )

+      {

+         for (j = 0; j*2 < tga_height; ++j)

+         {

+            int index1 = j * tga_width * tga_comp;

+            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;

+            for (i = tga_width * tga_comp; i > 0; --i)

+            {

+               unsigned char temp = tga_data[index1];

+               tga_data[index1] = tga_data[index2];

+               tga_data[index2] = temp;

+               ++index1;

+               ++index2;

+            }

+         }

+      }

+      //   clear my palette, if I had one

+      if ( tga_palette != NULL )

+      {

+         STBI_FREE( tga_palette );

+      }

+   }

+

+   // swap RGB - if the source data was RGB16, it already is in the right order

+   if (tga_comp >= 3 && !tga_rgb16)

+   {

+      unsigned char* tga_pixel = tga_data;

+      for (i=0; i < tga_width * tga_height; ++i)

+      {

+         unsigned char temp = tga_pixel[0];

+         tga_pixel[0] = tga_pixel[2];

+         tga_pixel[2] = temp;

+         tga_pixel += tga_comp;

+      }

+   }

+

+   // convert to target component count

+   if (req_comp && req_comp != tga_comp)

+      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);

+

+   //   the things I do to get rid of an error message, and yet keep

+   //   Microsoft's C compilers happy... [8^(

+   tga_palette_start = tga_palette_len = tga_palette_bits =

+         tga_x_origin = tga_y_origin = 0;

+   STBI_NOTUSED(tga_palette_start);

+   //   OK, done

+   return tga_data;

+}

+#endif

+

+// *************************************************************************************************

+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB

+

+#ifndef STBI_NO_PSD

+static int stbi__psd_test(stbi__context *s)

+{

+   int r = (stbi__get32be(s) == 0x38425053);

+   stbi__rewind(s);

+   return r;

+}

+

+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)

+{

+   int count, nleft, len;

+

+   count = 0;

+   while ((nleft = pixelCount - count) > 0) {

+      len = stbi__get8(s);

+      if (len == 128) {

+         // No-op.

+      } else if (len < 128) {

+         // Copy next len+1 bytes literally.

+         len++;

+         if (len > nleft) return 0; // corrupt data

+         count += len;

+         while (len) {

+            *p = stbi__get8(s);

+            p += 4;

+            len--;

+         }

+      } else if (len > 128) {

+         stbi_uc   val;

+         // Next -len+1 bytes in the dest are replicated from next source byte.

+         // (Interpret len as a negative 8-bit int.)

+         len = 257 - len;

+         if (len > nleft) return 0; // corrupt data

+         val = stbi__get8(s);

+         count += len;

+         while (len) {

+            *p = val;

+            p += 4;

+            len--;

+         }

+      }

+   }

+

+   return 1;

+}

+

+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)

+{

+   int pixelCount;

+   int channelCount, compression;

+   int channel, i;

+   int bitdepth;

+   int w,h;

+   stbi_uc *out;

+   STBI_NOTUSED(ri);

+

+   // Check identifier

+   if (stbi__get32be(s) != 0x38425053)   // "8BPS"

+      return stbi__errpuc("not PSD", "Corrupt PSD image");

+

+   // Check file type version.

+   if (stbi__get16be(s) != 1)

+      return stbi__errpuc("wrong version", "Unsupported version of PSD image");

+

+   // Skip 6 reserved bytes.

+   stbi__skip(s, 6 );

+

+   // Read the number of channels (R, G, B, A, etc).

+   channelCount = stbi__get16be(s);

+   if (channelCount < 0 || channelCount > 16)

+      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");

+

+   // Read the rows and columns of the image.

+   h = stbi__get32be(s);

+   w = stbi__get32be(s);

+

+   if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+   if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+

+   // Make sure the depth is 8 bits.

+   bitdepth = stbi__get16be(s);

+   if (bitdepth != 8 && bitdepth != 16)

+      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");

+

+   // Make sure the color mode is RGB.

+   // Valid options are:

+   //   0: Bitmap

+   //   1: Grayscale

+   //   2: Indexed color

+   //   3: RGB color

+   //   4: CMYK color

+   //   7: Multichannel

+   //   8: Duotone

+   //   9: Lab color

+   if (stbi__get16be(s) != 3)

+      return stbi__errpuc("wrong color format", "PSD is not in RGB color format");

+

+   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)

+   stbi__skip(s,stbi__get32be(s) );

+

+   // Skip the image resources.  (resolution, pen tool paths, etc)

+   stbi__skip(s, stbi__get32be(s) );

+

+   // Skip the reserved data.

+   stbi__skip(s, stbi__get32be(s) );

+

+   // Find out if the data is compressed.

+   // Known values:

+   //   0: no compression

+   //   1: RLE compressed

+   compression = stbi__get16be(s);

+   if (compression > 1)

+      return stbi__errpuc("bad compression", "PSD has an unknown compression format");

+

+   // Check size

+   if (!stbi__mad3sizes_valid(4, w, h, 0))

+      return stbi__errpuc("too large", "Corrupt PSD");

+

+   // Create the destination image.

+

+   if (!compression && bitdepth == 16 && bpc == 16) {

+      out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);

+      ri->bits_per_channel = 16;

+   } else

+      out = (stbi_uc *) stbi__malloc(4 * w*h);

+

+   if (!out) return stbi__errpuc("outofmem", "Out of memory");

+   pixelCount = w*h;

+

+   // Initialize the data to zero.

+   //memset( out, 0, pixelCount * 4 );

+

+   // Finally, the image data.

+   if (compression) {

+      // RLE as used by .PSD and .TIFF

+      // Loop until you get the number of unpacked bytes you are expecting:

+      //     Read the next source byte into n.

+      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.

+      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.

+      //     Else if n is 128, noop.

+      // Endloop

+

+      // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,

+      // which we're going to just skip.

+      stbi__skip(s, h * channelCount * 2 );

+

+      // Read the RLE data by channel.

+      for (channel = 0; channel < 4; channel++) {

+         stbi_uc *p;

+

+         p = out+channel;

+         if (channel >= channelCount) {

+            // Fill this channel with default data.

+            for (i = 0; i < pixelCount; i++, p += 4)

+               *p = (channel == 3 ? 255 : 0);

+         } else {

+            // Read the RLE data.

+            if (!stbi__psd_decode_rle(s, p, pixelCount)) {

+               STBI_FREE(out);

+               return stbi__errpuc("corrupt", "bad RLE data");

+            }

+         }

+      }

+

+   } else {

+      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)

+      // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.

+

+      // Read the data by channel.

+      for (channel = 0; channel < 4; channel++) {

+         if (channel >= channelCount) {

+            // Fill this channel with default data.

+            if (bitdepth == 16 && bpc == 16) {

+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;

+               stbi__uint16 val = channel == 3 ? 65535 : 0;

+               for (i = 0; i < pixelCount; i++, q += 4)

+                  *q = val;

+            } else {

+               stbi_uc *p = out+channel;

+               stbi_uc val = channel == 3 ? 255 : 0;

+               for (i = 0; i < pixelCount; i++, p += 4)

+                  *p = val;

+            }

+         } else {

+            if (ri->bits_per_channel == 16) {    // output bpc

+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;

+               for (i = 0; i < pixelCount; i++, q += 4)

+                  *q = (stbi__uint16) stbi__get16be(s);

+            } else {

+               stbi_uc *p = out+channel;

+               if (bitdepth == 16) {  // input bpc

+                  for (i = 0; i < pixelCount; i++, p += 4)

+                     *p = (stbi_uc) (stbi__get16be(s) >> 8);

+               } else {

+                  for (i = 0; i < pixelCount; i++, p += 4)

+                     *p = stbi__get8(s);

+               }

+            }

+         }

+      }

+   }

+

+   // remove weird white matte from PSD

+   if (channelCount >= 4) {

+      if (ri->bits_per_channel == 16) {

+         for (i=0; i < w*h; ++i) {

+            stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;

+            if (pixel[3] != 0 && pixel[3] != 65535) {

+               float a = pixel[3] / 65535.0f;

+               float ra = 1.0f / a;

+               float inv_a = 65535.0f * (1 - ra);

+               pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);

+               pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);

+               pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);

+            }

+         }

+      } else {

+         for (i=0; i < w*h; ++i) {

+            unsigned char *pixel = out + 4*i;

+            if (pixel[3] != 0 && pixel[3] != 255) {

+               float a = pixel[3] / 255.0f;

+               float ra = 1.0f / a;

+               float inv_a = 255.0f * (1 - ra);

+               pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);

+               pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);

+               pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);

+            }

+         }

+      }

+   }

+

+   // convert to desired output format

+   if (req_comp && req_comp != 4) {

+      if (ri->bits_per_channel == 16)

+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);

+      else

+         out = stbi__convert_format(out, 4, req_comp, w, h);

+      if (out == NULL) return out; // stbi__convert_format frees input on failure

+   }

+

+   if (comp) *comp = 4;

+   *y = h;

+   *x = w;

+

+   return out;

+}

+#endif

+

+// *************************************************************************************************

+// Softimage PIC loader

+// by Tom Seddon

+//

+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format

+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/

+

+#ifndef STBI_NO_PIC

+static int stbi__pic_is4(stbi__context *s,const char *str)

+{

+   int i;

+   for (i=0; i<4; ++i)

+      if (stbi__get8(s) != (stbi_uc)str[i])

+         return 0;

+

+   return 1;

+}

+

+static int stbi__pic_test_core(stbi__context *s)

+{

+   int i;

+

+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))

+      return 0;

+

+   for(i=0;i<84;++i)

+      stbi__get8(s);

+

+   if (!stbi__pic_is4(s,"PICT"))

+      return 0;

+

+   return 1;

+}

+

+typedef struct

+{

+   stbi_uc size,type,channel;

+} stbi__pic_packet;

+

+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)

+{

+   int mask=0x80, i;

+

+   for (i=0; i<4; ++i, mask>>=1) {

+      if (channel & mask) {

+         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");

+         dest[i]=stbi__get8(s);

+      }

+   }

+

+   return dest;

+}

+

+static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)

+{

+   int mask=0x80,i;

+

+   for (i=0;i<4; ++i, mask>>=1)

+      if (channel&mask)

+         dest[i]=src[i];

+}

+

+static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)

+{

+   int act_comp=0,num_packets=0,y,chained;

+   stbi__pic_packet packets[10];

+

+   // this will (should...) cater for even some bizarre stuff like having data

+    // for the same channel in multiple packets.

+   do {

+      stbi__pic_packet *packet;

+

+      if (num_packets==sizeof(packets)/sizeof(packets[0]))

+         return stbi__errpuc("bad format","too many packets");

+

+      packet = &packets[num_packets++];

+

+      chained = stbi__get8(s);

+      packet->size    = stbi__get8(s);

+      packet->type    = stbi__get8(s);

+      packet->channel = stbi__get8(s);

+

+      act_comp |= packet->channel;

+

+      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");

+      if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");

+   } while (chained);

+

+   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?

+

+   for(y=0; y<height; ++y) {

+      int packet_idx;

+

+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {

+         stbi__pic_packet *packet = &packets[packet_idx];

+         stbi_uc *dest = result+y*width*4;

+

+         switch (packet->type) {

+            default:

+               return stbi__errpuc("bad format","packet has bad compression type");

+

+            case 0: {//uncompressed

+               int x;

+

+               for(x=0;x<width;++x, dest+=4)

+                  if (!stbi__readval(s,packet->channel,dest))

+                     return 0;

+               break;

+            }

+

+            case 1://Pure RLE

+               {

+                  int left=width, i;

+

+                  while (left>0) {

+                     stbi_uc count,value[4];

+

+                     count=stbi__get8(s);

+                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");

+

+                     if (count > left)

+                        count = (stbi_uc) left;

+

+                     if (!stbi__readval(s,packet->channel,value))  return 0;

+

+                     for(i=0; i<count; ++i,dest+=4)

+                        stbi__copyval(packet->channel,dest,value);

+                     left -= count;

+                  }

+               }

+               break;

+

+            case 2: {//Mixed RLE

+               int left=width;

+               while (left>0) {

+                  int count = stbi__get8(s), i;

+                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");

+

+                  if (count >= 128) { // Repeated

+                     stbi_uc value[4];

+

+                     if (count==128)

+                        count = stbi__get16be(s);

+                     else

+                        count -= 127;

+                     if (count > left)

+                        return stbi__errpuc("bad file","scanline overrun");

+

+                     if (!stbi__readval(s,packet->channel,value))

+                        return 0;

+

+                     for(i=0;i<count;++i, dest += 4)

+                        stbi__copyval(packet->channel,dest,value);

+                  } else { // Raw

+                     ++count;

+                     if (count>left) return stbi__errpuc("bad file","scanline overrun");

+

+                     for(i=0;i<count;++i, dest+=4)

+                        if (!stbi__readval(s,packet->channel,dest))

+                           return 0;

+                  }

+                  left-=count;

+               }

+               break;

+            }

+         }

+      }

+   }

+

+   return result;

+}

+

+static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)

+{

+   stbi_uc *result;

+   int i, x,y, internal_comp;

+   STBI_NOTUSED(ri);

+

+   if (!comp) comp = &internal_comp;

+

+   for (i=0; i<92; ++i)

+      stbi__get8(s);

+

+   x = stbi__get16be(s);

+   y = stbi__get16be(s);

+

+   if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+   if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+

+   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");

+   if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");

+

+   stbi__get32be(s); //skip `ratio'

+   stbi__get16be(s); //skip `fields'

+   stbi__get16be(s); //skip `pad'

+

+   // intermediate buffer is RGBA

+   result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);

+   if (!result) return stbi__errpuc("outofmem", "Out of memory");

+   memset(result, 0xff, x*y*4);

+

+   if (!stbi__pic_load_core(s,x,y,comp, result)) {

+      STBI_FREE(result);

+      result=0;

+   }

+   *px = x;

+   *py = y;

+   if (req_comp == 0) req_comp = *comp;

+   result=stbi__convert_format(result,4,req_comp,x,y);

+

+   return result;

+}

+

+static int stbi__pic_test(stbi__context *s)

+{

+   int r = stbi__pic_test_core(s);

+   stbi__rewind(s);

+   return r;

+}

+#endif

+

+// *************************************************************************************************

+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb

+

+#ifndef STBI_NO_GIF

+typedef struct

+{

+   stbi__int16 prefix;

+   stbi_uc first;

+   stbi_uc suffix;

+} stbi__gif_lzw;

+

+typedef struct

+{

+   int w,h;

+   stbi_uc *out;                 // output buffer (always 4 components)

+   stbi_uc *background;          // The current "background" as far as a gif is concerned

+   stbi_uc *history;

+   int flags, bgindex, ratio, transparent, eflags;

+   stbi_uc  pal[256][4];

+   stbi_uc lpal[256][4];

+   stbi__gif_lzw codes[8192];

+   stbi_uc *color_table;

+   int parse, step;

+   int lflags;

+   int start_x, start_y;

+   int max_x, max_y;

+   int cur_x, cur_y;

+   int line_size;

+   int delay;

+} stbi__gif;

+

+static int stbi__gif_test_raw(stbi__context *s)

+{

+   int sz;

+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;

+   sz = stbi__get8(s);

+   if (sz != '9' && sz != '7') return 0;

+   if (stbi__get8(s) != 'a') return 0;

+   return 1;

+}

+

+static int stbi__gif_test(stbi__context *s)

+{

+   int r = stbi__gif_test_raw(s);

+   stbi__rewind(s);

+   return r;

+}

+

+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)

+{

+   int i;

+   for (i=0; i < num_entries; ++i) {

+      pal[i][2] = stbi__get8(s);

+      pal[i][1] = stbi__get8(s);

+      pal[i][0] = stbi__get8(s);

+      pal[i][3] = transp == i ? 0 : 255;

+   }

+}

+

+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)

+{

+   stbi_uc version;

+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')

+      return stbi__err("not GIF", "Corrupt GIF");

+

+   version = stbi__get8(s);

+   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");

+   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");

+

+   stbi__g_failure_reason = "";

+   g->w = stbi__get16le(s);

+   g->h = stbi__get16le(s);

+   g->flags = stbi__get8(s);

+   g->bgindex = stbi__get8(s);

+   g->ratio = stbi__get8(s);

+   g->transparent = -1;

+

+   if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");

+   if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");

+

+   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments

+

+   if (is_info) return 1;

+

+   if (g->flags & 0x80)

+      stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);

+

+   return 1;

+}

+

+static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)

+{

+   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));

+   if (!g) return stbi__err("outofmem", "Out of memory");

+   if (!stbi__gif_header(s, g, comp, 1)) {

+      STBI_FREE(g);

+      stbi__rewind( s );

+      return 0;

+   }

+   if (x) *x = g->w;

+   if (y) *y = g->h;

+   STBI_FREE(g);

+   return 1;

+}

+

+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)

+{

+   stbi_uc *p, *c;

+   int idx;

+

+   // recurse to decode the prefixes, since the linked-list is backwards,

+   // and working backwards through an interleaved image would be nasty

+   if (g->codes[code].prefix >= 0)

+      stbi__out_gif_code(g, g->codes[code].prefix);

+

+   if (g->cur_y >= g->max_y) return;

+

+   idx = g->cur_x + g->cur_y;

+   p = &g->out[idx];

+   g->history[idx / 4] = 1;

+

+   c = &g->color_table[g->codes[code].suffix * 4];

+   if (c[3] > 128) { // don't render transparent pixels;

+      p[0] = c[2];

+      p[1] = c[1];

+      p[2] = c[0];

+      p[3] = c[3];

+   }

+   g->cur_x += 4;

+

+   if (g->cur_x >= g->max_x) {

+      g->cur_x = g->start_x;

+      g->cur_y += g->step;

+

+      while (g->cur_y >= g->max_y && g->parse > 0) {

+         g->step = (1 << g->parse) * g->line_size;

+         g->cur_y = g->start_y + (g->step >> 1);

+         --g->parse;

+      }

+   }

+}

+

+static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)

+{

+   stbi_uc lzw_cs;

+   stbi__int32 len, init_code;

+   stbi__uint32 first;

+   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;

+   stbi__gif_lzw *p;

+

+   lzw_cs = stbi__get8(s);

+   if (lzw_cs > 12) return NULL;

+   clear = 1 << lzw_cs;

+   first = 1;

+   codesize = lzw_cs + 1;

+   codemask = (1 << codesize) - 1;

+   bits = 0;

+   valid_bits = 0;

+   for (init_code = 0; init_code < clear; init_code++) {

+      g->codes[init_code].prefix = -1;

+      g->codes[init_code].first = (stbi_uc) init_code;

+      g->codes[init_code].suffix = (stbi_uc) init_code;

+   }

+

+   // support no starting clear code

+   avail = clear+2;

+   oldcode = -1;

+

+   len = 0;

+   for(;;) {

+      if (valid_bits < codesize) {

+         if (len == 0) {

+            len = stbi__get8(s); // start new block

+            if (len == 0)

+               return g->out;

+         }

+         --len;

+         bits |= (stbi__int32) stbi__get8(s) << valid_bits;

+         valid_bits += 8;

+      } else {

+         stbi__int32 code = bits & codemask;

+         bits >>= codesize;

+         valid_bits -= codesize;

+         // @OPTIMIZE: is there some way we can accelerate the non-clear path?

+         if (code == clear) {  // clear code

+            codesize = lzw_cs + 1;

+            codemask = (1 << codesize) - 1;

+            avail = clear + 2;

+            oldcode = -1;

+            first = 0;

+         } else if (code == clear + 1) { // end of stream code

+            stbi__skip(s, len);

+            while ((len = stbi__get8(s)) > 0)

+               stbi__skip(s,len);

+            return g->out;

+         } else if (code <= avail) {

+            if (first) {

+               return stbi__errpuc("no clear code", "Corrupt GIF");

+            }

+

+            if (oldcode >= 0) {

+               p = &g->codes[avail++];

+               if (avail > 8192) {

+                  return stbi__errpuc("too many codes", "Corrupt GIF");

+               }

+

+               p->prefix = (stbi__int16) oldcode;

+               p->first = g->codes[oldcode].first;

+               p->suffix = (code == avail) ? p->first : g->codes[code].first;

+            } else if (code == avail)

+               return stbi__errpuc("illegal code in raster", "Corrupt GIF");

+

+            stbi__out_gif_code(g, (stbi__uint16) code);

+

+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {

+               codesize++;

+               codemask = (1 << codesize) - 1;

+            }

+

+            oldcode = code;

+         } else {

+            return stbi__errpuc("illegal code in raster", "Corrupt GIF");

+         }

+      }

+   }

+}

+

+// this function is designed to support animated gifs, although stb_image doesn't support it

+// two back is the image from two frames ago, used for a very specific disposal format

+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)

+{

+   int dispose;

+   int first_frame;

+   int pi;

+   int pcount;

+   STBI_NOTUSED(req_comp);

+

+   // on first frame, any non-written pixels get the background colour (non-transparent)

+   first_frame = 0;

+   if (g->out == 0) {

+      if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header

+      if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))

+         return stbi__errpuc("too large", "GIF image is too large");

+      pcount = g->w * g->h;

+      g->out = (stbi_uc *) stbi__malloc(4 * pcount);

+      g->background = (stbi_uc *) stbi__malloc(4 * pcount);

+      g->history = (stbi_uc *) stbi__malloc(pcount);

+      if (!g->out || !g->background || !g->history)

+         return stbi__errpuc("outofmem", "Out of memory");

+

+      // image is treated as "transparent" at the start - ie, nothing overwrites the current background;

+      // background colour is only used for pixels that are not rendered first frame, after that "background"

+      // color refers to the color that was there the previous frame.

+      memset(g->out, 0x00, 4 * pcount);

+      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)

+      memset(g->history, 0x00, pcount);        // pixels that were affected previous frame

+      first_frame = 1;

+   } else {

+      // second frame - how do we dispose of the previous one?

+      dispose = (g->eflags & 0x1C) >> 2;

+      pcount = g->w * g->h;

+

+      if ((dispose == 3) && (two_back == 0)) {

+         dispose = 2; // if I don't have an image to revert back to, default to the old background

+      }

+

+      if (dispose == 3) { // use previous graphic

+         for (pi = 0; pi < pcount; ++pi) {

+            if (g->history[pi]) {

+               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );

+            }

+         }

+      } else if (dispose == 2) {

+         // restore what was changed last frame to background before that frame;

+         for (pi = 0; pi < pcount; ++pi) {

+            if (g->history[pi]) {

+               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );

+            }

+         }

+      } else {

+         // This is a non-disposal case eithe way, so just

+         // leave the pixels as is, and they will become the new background

+         // 1: do not dispose

+         // 0:  not specified.

+      }

+

+      // background is what out is after the undoing of the previou frame;

+      memcpy( g->background, g->out, 4 * g->w * g->h );

+   }

+

+   // clear my history;

+   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame

+

+   for (;;) {

+      int tag = stbi__get8(s);

+      switch (tag) {

+         case 0x2C: /* Image Descriptor */

+         {

+            stbi__int32 x, y, w, h;

+            stbi_uc *o;

+

+            x = stbi__get16le(s);

+            y = stbi__get16le(s);

+            w = stbi__get16le(s);

+            h = stbi__get16le(s);

+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))

+               return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");

+

+            g->line_size = g->w * 4;

+            g->start_x = x * 4;

+            g->start_y = y * g->line_size;

+            g->max_x   = g->start_x + w * 4;

+            g->max_y   = g->start_y + h * g->line_size;

+            g->cur_x   = g->start_x;

+            g->cur_y   = g->start_y;

+

+            // if the width of the specified rectangle is 0, that means

+            // we may not see *any* pixels or the image is malformed;

+            // to make sure this is caught, move the current y down to

+            // max_y (which is what out_gif_code checks).

+            if (w == 0)

+               g->cur_y = g->max_y;

+

+            g->lflags = stbi__get8(s);

+

+            if (g->lflags & 0x40) {

+               g->step = 8 * g->line_size; // first interlaced spacing

+               g->parse = 3;

+            } else {

+               g->step = g->line_size;

+               g->parse = 0;

+            }

+

+            if (g->lflags & 0x80) {

+               stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);

+               g->color_table = (stbi_uc *) g->lpal;

+            } else if (g->flags & 0x80) {

+               g->color_table = (stbi_uc *) g->pal;

+            } else

+               return stbi__errpuc("missing color table", "Corrupt GIF");

+

+            o = stbi__process_gif_raster(s, g);

+            if (!o) return NULL;

+

+            // if this was the first frame,

+            pcount = g->w * g->h;

+            if (first_frame && (g->bgindex > 0)) {

+               // if first frame, any pixel not drawn to gets the background color

+               for (pi = 0; pi < pcount; ++pi) {

+                  if (g->history[pi] == 0) {

+                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;

+                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );

+                  }

+               }

+            }

+

+            return o;

+         }

+

+         case 0x21: // Comment Extension.

+         {

+            int len;

+            int ext = stbi__get8(s);

+            if (ext == 0xF9) { // Graphic Control Extension.

+               len = stbi__get8(s);

+               if (len == 4) {

+                  g->eflags = stbi__get8(s);

+                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.

+

+                  // unset old transparent

+                  if (g->transparent >= 0) {

+                     g->pal[g->transparent][3] = 255;

+                  }

+                  if (g->eflags & 0x01) {

+                     g->transparent = stbi__get8(s);

+                     if (g->transparent >= 0) {

+                        g->pal[g->transparent][3] = 0;

+                     }

+                  } else {

+                     // don't need transparent

+                     stbi__skip(s, 1);

+                     g->transparent = -1;

+                  }

+               } else {

+                  stbi__skip(s, len);

+                  break;

+               }

+            }

+            while ((len = stbi__get8(s)) != 0) {

+               stbi__skip(s, len);

+            }

+            break;

+         }

+

+         case 0x3B: // gif stream termination code

+            return (stbi_uc *) s; // using '1' causes warning on some compilers

+

+         default:

+            return stbi__errpuc("unknown code", "Corrupt GIF");

+      }

+   }

+}

+

+static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)

+{

+   STBI_FREE(g->out);

+   STBI_FREE(g->history);

+   STBI_FREE(g->background);

+

+   if (out) STBI_FREE(out);

+   if (delays && *delays) STBI_FREE(*delays);

+   return stbi__errpuc("outofmem", "Out of memory");

+}

+

+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)

+{

+   if (stbi__gif_test(s)) {

+      int layers = 0;

+      stbi_uc *u = 0;

+      stbi_uc *out = 0;

+      stbi_uc *two_back = 0;

+      stbi__gif g;

+      int stride;

+      int out_size = 0;

+      int delays_size = 0;

+

+      STBI_NOTUSED(out_size);

+      STBI_NOTUSED(delays_size);

+

+      memset(&g, 0, sizeof(g));

+      if (delays) {

+         *delays = 0;

+      }

+

+      do {

+         u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);

+         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker

+

+         if (u) {

+            *x = g.w;

+            *y = g.h;

+            ++layers;

+            stride = g.w * g.h * 4;

+

+            if (out) {

+               void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );

+               if (!tmp)

+                  return stbi__load_gif_main_outofmem(&g, out, delays);

+               else {

+                   out = (stbi_uc*) tmp;

+                   out_size = layers * stride;

+               }

+

+               if (delays) {

+                  int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );

+                  if (!new_delays)

+                     return stbi__load_gif_main_outofmem(&g, out, delays);

+                  *delays = new_delays;

+                  delays_size = layers * sizeof(int);

+               }

+            } else {

+               out = (stbi_uc*)stbi__malloc( layers * stride );

+               if (!out)

+                  return stbi__load_gif_main_outofmem(&g, out, delays);

+               out_size = layers * stride;

+               if (delays) {

+                  *delays = (int*) stbi__malloc( layers * sizeof(int) );

+                  if (!*delays)

+                     return stbi__load_gif_main_outofmem(&g, out, delays);

+                  delays_size = layers * sizeof(int);

+               }

+            }

+            memcpy( out + ((layers - 1) * stride), u, stride );

+            if (layers >= 2) {

+               two_back = out - 2 * stride;

+            }

+

+            if (delays) {

+               (*delays)[layers - 1U] = g.delay;

+            }

+         }

+      } while (u != 0);

+

+      // free temp buffer;

+      STBI_FREE(g.out);

+      STBI_FREE(g.history);

+      STBI_FREE(g.background);

+

+      // do the final conversion after loading everything;

+      if (req_comp && req_comp != 4)

+         out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);

+

+      *z = layers;

+      return out;

+   } else {

+      return stbi__errpuc("not GIF", "Image was not as a gif type.");

+   }

+}

+

+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)

+{

+   stbi_uc *u = 0;

+   stbi__gif g;

+   memset(&g, 0, sizeof(g));

+   STBI_NOTUSED(ri);

+

+   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);

+   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker

+   if (u) {

+      *x = g.w;

+      *y = g.h;

+

+      // moved conversion to after successful load so that the same

+      // can be done for multiple frames.

+      if (req_comp && req_comp != 4)

+         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);

+   } else if (g.out) {

+      // if there was an error and we allocated an image buffer, free it!

+      STBI_FREE(g.out);

+   }

+

+   // free buffers needed for multiple frame loading;

+   STBI_FREE(g.history);

+   STBI_FREE(g.background);

+

+   return u;

+}

+

+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   return stbi__gif_info_raw(s,x,y,comp);

+}

+#endif

+

+// *************************************************************************************************

+// Radiance RGBE HDR loader

+// originally by Nicolas Schulz

+#ifndef STBI_NO_HDR

+static int stbi__hdr_test_core(stbi__context *s, const char *signature)

+{

+   int i;

+   for (i=0; signature[i]; ++i)

+      if (stbi__get8(s) != signature[i])

+          return 0;

+   stbi__rewind(s);

+   return 1;

+}

+

+static int stbi__hdr_test(stbi__context* s)

+{

+   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");

+   stbi__rewind(s);

+   if(!r) {

+       r = stbi__hdr_test_core(s, "#?RGBE\n");

+       stbi__rewind(s);

+   }

+   return r;

+}

+

+#define STBI__HDR_BUFLEN  1024

+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)

+{

+   int len=0;

+   char c = '\0';

+

+   c = (char) stbi__get8(z);

+

+   while (!stbi__at_eof(z) && c != '\n') {

+      buffer[len++] = c;

+      if (len == STBI__HDR_BUFLEN-1) {

+         // flush to end of line

+         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')

+            ;

+         break;

+      }

+      c = (char) stbi__get8(z);

+   }

+

+   buffer[len] = 0;

+   return buffer;

+}

+

+static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)

+{

+   if ( input[3] != 0 ) {

+      float f1;

+      // Exponent

+      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));

+      if (req_comp <= 2)

+         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;

+      else {

+         output[0] = input[0] * f1;

+         output[1] = input[1] * f1;

+         output[2] = input[2] * f1;

+      }

+      if (req_comp == 2) output[1] = 1;

+      if (req_comp == 4) output[3] = 1;

+   } else {

+      switch (req_comp) {

+         case 4: output[3] = 1; /* fallthrough */

+         case 3: output[0] = output[1] = output[2] = 0;

+                 break;

+         case 2: output[1] = 1; /* fallthrough */

+         case 1: output[0] = 0;

+                 break;

+      }

+   }

+}

+

+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)

+{

+   char buffer[STBI__HDR_BUFLEN];

+   char *token;

+   int valid = 0;

+   int width, height;

+   stbi_uc *scanline;

+   float *hdr_data;

+   int len;

+   unsigned char count, value;

+   int i, j, k, c1,c2, z;

+   const char *headerToken;

+   STBI_NOTUSED(ri);

+

+   // Check identifier

+   headerToken = stbi__hdr_gettoken(s,buffer);

+   if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)

+      return stbi__errpf("not HDR", "Corrupt HDR image");

+

+   // Parse header

+   for(;;) {

+      token = stbi__hdr_gettoken(s,buffer);

+      if (token[0] == 0) break;

+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;

+   }

+

+   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");

+

+   // Parse width and height

+   // can't use sscanf() if we're not using stdio!

+   token = stbi__hdr_gettoken(s,buffer);

+   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");

+   token += 3;

+   height = (int) strtol(token, &token, 10);

+   while (*token == ' ') ++token;

+   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");

+   token += 3;

+   width = (int) strtol(token, NULL, 10);

+

+   if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");

+   if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");

+

+   *x = width;

+   *y = height;

+

+   if (comp) *comp = 3;

+   if (req_comp == 0) req_comp = 3;

+

+   if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))

+      return stbi__errpf("too large", "HDR image is too large");

+

+   // Read data

+   hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);

+   if (!hdr_data)

+      return stbi__errpf("outofmem", "Out of memory");

+

+   // Load image data

+   // image data is stored as some number of sca

+   if ( width < 8 || width >= 32768) {

+      // Read flat data

+      for (j=0; j < height; ++j) {

+         for (i=0; i < width; ++i) {

+            stbi_uc rgbe[4];

+           main_decode_loop:

+            stbi__getn(s, rgbe, 4);

+            stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);

+         }

+      }

+   } else {

+      // Read RLE-encoded data

+      scanline = NULL;

+

+      for (j = 0; j < height; ++j) {

+         c1 = stbi__get8(s);

+         c2 = stbi__get8(s);

+         len = stbi__get8(s);

+         if (c1 != 2 || c2 != 2 || (len & 0x80)) {

+            // not run-length encoded, so we have to actually use THIS data as a decoded

+            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)

+            stbi_uc rgbe[4];

+            rgbe[0] = (stbi_uc) c1;

+            rgbe[1] = (stbi_uc) c2;

+            rgbe[2] = (stbi_uc) len;

+            rgbe[3] = (stbi_uc) stbi__get8(s);

+            stbi__hdr_convert(hdr_data, rgbe, req_comp);

+            i = 1;

+            j = 0;

+            STBI_FREE(scanline);

+            goto main_decode_loop; // yes, this makes no sense

+         }

+         len <<= 8;

+         len |= stbi__get8(s);

+         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }

+         if (scanline == NULL) {

+            scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);

+            if (!scanline) {

+               STBI_FREE(hdr_data);

+               return stbi__errpf("outofmem", "Out of memory");

+            }

+         }

+

+         for (k = 0; k < 4; ++k) {

+            int nleft;

+            i = 0;

+            while ((nleft = width - i) > 0) {

+               count = stbi__get8(s);

+               if (count > 128) {

+                  // Run

+                  value = stbi__get8(s);

+                  count -= 128;

+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }

+                  for (z = 0; z < count; ++z)

+                     scanline[i++ * 4 + k] = value;

+               } else {

+                  // Dump

+                  if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }

+                  for (z = 0; z < count; ++z)

+                     scanline[i++ * 4 + k] = stbi__get8(s);

+               }

+            }

+         }

+         for (i=0; i < width; ++i)

+            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);

+      }

+      if (scanline)

+         STBI_FREE(scanline);

+   }

+

+   return hdr_data;

+}

+

+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   char buffer[STBI__HDR_BUFLEN];

+   char *token;

+   int valid = 0;

+   int dummy;

+

+   if (!x) x = &dummy;

+   if (!y) y = &dummy;

+   if (!comp) comp = &dummy;

+

+   if (stbi__hdr_test(s) == 0) {

+       stbi__rewind( s );

+       return 0;

+   }

+

+   for(;;) {

+      token = stbi__hdr_gettoken(s,buffer);

+      if (token[0] == 0) break;

+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;

+   }

+

+   if (!valid) {

+       stbi__rewind( s );

+       return 0;

+   }

+   token = stbi__hdr_gettoken(s,buffer);

+   if (strncmp(token, "-Y ", 3)) {

+       stbi__rewind( s );

+       return 0;

+   }

+   token += 3;

+   *y = (int) strtol(token, &token, 10);

+   while (*token == ' ') ++token;

+   if (strncmp(token, "+X ", 3)) {

+       stbi__rewind( s );

+       return 0;

+   }

+   token += 3;

+   *x = (int) strtol(token, NULL, 10);

+   *comp = 3;

+   return 1;

+}

+#endif // STBI_NO_HDR

+

+#ifndef STBI_NO_BMP

+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   void *p;

+   stbi__bmp_data info;

+

+   info.all_a = 255;

+   p = stbi__bmp_parse_header(s, &info);

+   if (p == NULL) {

+      stbi__rewind( s );

+      return 0;

+   }

+   if (x) *x = s->img_x;

+   if (y) *y = s->img_y;

+   if (comp) {

+      if (info.bpp == 24 && info.ma == 0xff000000)

+         *comp = 3;

+      else

+         *comp = info.ma ? 4 : 3;

+   }

+   return 1;

+}

+#endif

+

+#ifndef STBI_NO_PSD

+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   int channelCount, dummy, depth;

+   if (!x) x = &dummy;

+   if (!y) y = &dummy;

+   if (!comp) comp = &dummy;

+   if (stbi__get32be(s) != 0x38425053) {

+       stbi__rewind( s );

+       return 0;

+   }

+   if (stbi__get16be(s) != 1) {

+       stbi__rewind( s );

+       return 0;

+   }

+   stbi__skip(s, 6);

+   channelCount = stbi__get16be(s);

+   if (channelCount < 0 || channelCount > 16) {

+       stbi__rewind( s );

+       return 0;

+   }

+   *y = stbi__get32be(s);

+   *x = stbi__get32be(s);

+   depth = stbi__get16be(s);

+   if (depth != 8 && depth != 16) {

+       stbi__rewind( s );

+       return 0;

+   }

+   if (stbi__get16be(s) != 3) {

+       stbi__rewind( s );

+       return 0;

+   }

+   *comp = 4;

+   return 1;

+}

+

+static int stbi__psd_is16(stbi__context *s)

+{

+   int channelCount, depth;

+   if (stbi__get32be(s) != 0x38425053) {

+       stbi__rewind( s );

+       return 0;

+   }

+   if (stbi__get16be(s) != 1) {

+       stbi__rewind( s );

+       return 0;

+   }

+   stbi__skip(s, 6);

+   channelCount = stbi__get16be(s);

+   if (channelCount < 0 || channelCount > 16) {

+       stbi__rewind( s );

+       return 0;

+   }

+   STBI_NOTUSED(stbi__get32be(s));

+   STBI_NOTUSED(stbi__get32be(s));

+   depth = stbi__get16be(s);

+   if (depth != 16) {

+       stbi__rewind( s );

+       return 0;

+   }

+   return 1;

+}

+#endif

+

+#ifndef STBI_NO_PIC

+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   int act_comp=0,num_packets=0,chained,dummy;

+   stbi__pic_packet packets[10];

+

+   if (!x) x = &dummy;

+   if (!y) y = &dummy;

+   if (!comp) comp = &dummy;

+

+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {

+      stbi__rewind(s);

+      return 0;

+   }

+

+   stbi__skip(s, 88);

+

+   *x = stbi__get16be(s);

+   *y = stbi__get16be(s);

+   if (stbi__at_eof(s)) {

+      stbi__rewind( s);

+      return 0;

+   }

+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {

+      stbi__rewind( s );

+      return 0;

+   }

+

+   stbi__skip(s, 8);

+

+   do {

+      stbi__pic_packet *packet;

+

+      if (num_packets==sizeof(packets)/sizeof(packets[0]))

+         return 0;

+

+      packet = &packets[num_packets++];

+      chained = stbi__get8(s);

+      packet->size    = stbi__get8(s);

+      packet->type    = stbi__get8(s);

+      packet->channel = stbi__get8(s);

+      act_comp |= packet->channel;

+

+      if (stbi__at_eof(s)) {

+          stbi__rewind( s );

+          return 0;

+      }

+      if (packet->size != 8) {

+          stbi__rewind( s );

+          return 0;

+      }

+   } while (chained);

+

+   *comp = (act_comp & 0x10 ? 4 : 3);

+

+   return 1;

+}

+#endif

+

+// *************************************************************************************************

+// Portable Gray Map and Portable Pixel Map loader

+// by Ken Miller

+//

+// PGM: http://netpbm.sourceforge.net/doc/pgm.html

+// PPM: http://netpbm.sourceforge.net/doc/ppm.html

+//

+// Known limitations:

+//    Does not support comments in the header section

+//    Does not support ASCII image data (formats P2 and P3)

+

+#ifndef STBI_NO_PNM

+

+static int      stbi__pnm_test(stbi__context *s)

+{

+   char p, t;

+   p = (char) stbi__get8(s);

+   t = (char) stbi__get8(s);

+   if (p != 'P' || (t != '5' && t != '6')) {

+       stbi__rewind( s );

+       return 0;

+   }

+   return 1;

+}

+

+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)

+{

+   stbi_uc *out;

+   STBI_NOTUSED(ri);

+

+   ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);

+   if (ri->bits_per_channel == 0)

+      return 0;

+

+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");

+

+   *x = s->img_x;

+   *y = s->img_y;

+   if (comp) *comp = s->img_n;

+

+   if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))

+      return stbi__errpuc("too large", "PNM too large");

+

+   out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);

+   if (!out) return stbi__errpuc("outofmem", "Out of memory");

+   stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8));

+

+   if (req_comp && req_comp != s->img_n) {

+      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);

+      if (out == NULL) return out; // stbi__convert_format frees input on failure

+   }

+   return out;

+}

+

+static int      stbi__pnm_isspace(char c)

+{

+   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';

+}

+

+static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)

+{

+   for (;;) {

+      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))

+         *c = (char) stbi__get8(s);

+

+      if (stbi__at_eof(s) || *c != '#')

+         break;

+

+      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )

+         *c = (char) stbi__get8(s);

+   }

+}

+

+static int      stbi__pnm_isdigit(char c)

+{

+   return c >= '0' && c <= '9';

+}

+

+static int      stbi__pnm_getinteger(stbi__context *s, char *c)

+{

+   int value = 0;

+

+   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {

+      value = value*10 + (*c - '0');

+      *c = (char) stbi__get8(s);

+   }

+

+   return value;

+}

+

+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)

+{

+   int maxv, dummy;

+   char c, p, t;

+

+   if (!x) x = &dummy;

+   if (!y) y = &dummy;

+   if (!comp) comp = &dummy;

+

+   stbi__rewind(s);

+

+   // Get identifier

+   p = (char) stbi__get8(s);

+   t = (char) stbi__get8(s);

+   if (p != 'P' || (t != '5' && t != '6')) {

+       stbi__rewind(s);

+       return 0;

+   }

+

+   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm

+

+   c = (char) stbi__get8(s);

+   stbi__pnm_skip_whitespace(s, &c);

+

+   *x = stbi__pnm_getinteger(s, &c); // read width

+   stbi__pnm_skip_whitespace(s, &c);

+

+   *y = stbi__pnm_getinteger(s, &c); // read height

+   stbi__pnm_skip_whitespace(s, &c);

+

+   maxv = stbi__pnm_getinteger(s, &c);  // read max value

+   if (maxv > 65535)

+      return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");

+   else if (maxv > 255)

+      return 16;

+   else

+      return 8;

+}

+

+static int stbi__pnm_is16(stbi__context *s)

+{

+   if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)

+	   return 1;

+   return 0;

+}

+#endif

+

+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)

+{

+   #ifndef STBI_NO_JPEG

+   if (stbi__jpeg_info(s, x, y, comp)) return 1;

+   #endif

+

+   #ifndef STBI_NO_PNG

+   if (stbi__png_info(s, x, y, comp))  return 1;

+   #endif

+

+   #ifndef STBI_NO_GIF

+   if (stbi__gif_info(s, x, y, comp))  return 1;

+   #endif

+

+   #ifndef STBI_NO_BMP

+   if (stbi__bmp_info(s, x, y, comp))  return 1;

+   #endif

+

+   #ifndef STBI_NO_PSD

+   if (stbi__psd_info(s, x, y, comp))  return 1;

+   #endif

+

+   #ifndef STBI_NO_PIC

+   if (stbi__pic_info(s, x, y, comp))  return 1;

+   #endif

+

+   #ifndef STBI_NO_PNM

+   if (stbi__pnm_info(s, x, y, comp))  return 1;

+   #endif

+

+   #ifndef STBI_NO_HDR

+   if (stbi__hdr_info(s, x, y, comp))  return 1;

+   #endif

+

+   // test tga last because it's a crappy test!

+   #ifndef STBI_NO_TGA

+   if (stbi__tga_info(s, x, y, comp))

+       return 1;

+   #endif

+   return stbi__err("unknown image type", "Image not of any known type, or corrupt");

+}

+

+static int stbi__is_16_main(stbi__context *s)

+{

+   #ifndef STBI_NO_PNG

+   if (stbi__png_is16(s))  return 1;

+   #endif

+

+   #ifndef STBI_NO_PSD

+   if (stbi__psd_is16(s))  return 1;

+   #endif

+

+   #ifndef STBI_NO_PNM

+   if (stbi__pnm_is16(s))  return 1;

+   #endif

+   return 0;

+}

+

+#ifndef STBI_NO_STDIO

+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)

+{

+    FILE *f = stbi__fopen(filename, "rb");

+    int result;

+    if (!f) return stbi__err("can't fopen", "Unable to open file");

+    result = stbi_info_from_file(f, x, y, comp);

+    fclose(f);

+    return result;

+}

+

+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)

+{

+   int r;

+   stbi__context s;

+   long pos = ftell(f);

+   stbi__start_file(&s, f);

+   r = stbi__info_main(&s,x,y,comp);

+   fseek(f,pos,SEEK_SET);

+   return r;

+}

+

+STBIDEF int stbi_is_16_bit(char const *filename)

+{

+    FILE *f = stbi__fopen(filename, "rb");

+    int result;

+    if (!f) return stbi__err("can't fopen", "Unable to open file");

+    result = stbi_is_16_bit_from_file(f);

+    fclose(f);

+    return result;

+}

+

+STBIDEF int stbi_is_16_bit_from_file(FILE *f)

+{

+   int r;

+   stbi__context s;

+   long pos = ftell(f);

+   stbi__start_file(&s, f);

+   r = stbi__is_16_main(&s);

+   fseek(f,pos,SEEK_SET);

+   return r;

+}

+#endif // !STBI_NO_STDIO

+

+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)

+{

+   stbi__context s;

+   stbi__start_mem(&s,buffer,len);

+   return stbi__info_main(&s,x,y,comp);

+}

+

+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)

+{

+   stbi__context s;

+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);

+   return stbi__info_main(&s,x,y,comp);

+}

+

+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)

+{

+   stbi__context s;

+   stbi__start_mem(&s,buffer,len);

+   return stbi__is_16_main(&s);

+}

+

+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)

+{

+   stbi__context s;

+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);

+   return stbi__is_16_main(&s);

+}

+

+#endif // STB_IMAGE_IMPLEMENTATION

+

+/*

+   revision history:

+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs

+      2.19  (2018-02-11) fix warning

+      2.18  (2018-01-30) fix warnings

+      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug

+                         1-bit BMP

+                         *_is_16_bit api

+                         avoid warnings

+      2.16  (2017-07-23) all functions have 16-bit variants;

+                         STBI_NO_STDIO works again;

+                         compilation fixes;

+                         fix rounding in unpremultiply;

+                         optimize vertical flip;

+                         disable raw_len validation;

+                         documentation fixes

+      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;

+                         warning fixes; disable run-time SSE detection on gcc;

+                         uniform handling of optional "return" values;

+                         thread-safe initialization of zlib tables

+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs

+      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now

+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes

+      2.11  (2016-04-02) allocate large structures on the stack

+                         remove white matting for transparent PSD

+                         fix reported channel count for PNG & BMP

+                         re-enable SSE2 in non-gcc 64-bit

+                         support RGB-formatted JPEG

+                         read 16-bit PNGs (only as 8-bit)

+      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED

+      2.09  (2016-01-16) allow comments in PNM files

+                         16-bit-per-pixel TGA (not bit-per-component)

+                         info() for TGA could break due to .hdr handling

+                         info() for BMP to shares code instead of sloppy parse

+                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc

+                         code cleanup

+      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA

+      2.07  (2015-09-13) fix compiler warnings

+                         partial animated GIF support

+                         limited 16-bpc PSD support

+                         #ifdef unused functions

+                         bug with < 92 byte PIC,PNM,HDR,TGA

+      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value

+      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning

+      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit

+      2.03  (2015-04-12) extra corruption checking (mmozeiko)

+                         stbi_set_flip_vertically_on_load (nguillemot)

+                         fix NEON support; fix mingw support

+      2.02  (2015-01-19) fix incorrect assert, fix warning

+      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2

+      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG

+      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)

+                         progressive JPEG (stb)

+                         PGM/PPM support (Ken Miller)

+                         STBI_MALLOC,STBI_REALLOC,STBI_FREE

+                         GIF bugfix -- seemingly never worked

+                         STBI_NO_*, STBI_ONLY_*

+      1.48  (2014-12-14) fix incorrectly-named assert()

+      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)

+                         optimize PNG (ryg)

+                         fix bug in interlaced PNG with user-specified channel count (stb)

+      1.46  (2014-08-26)

+              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG

+      1.45  (2014-08-16)

+              fix MSVC-ARM internal compiler error by wrapping malloc

+      1.44  (2014-08-07)

+              various warning fixes from Ronny Chevalier

+      1.43  (2014-07-15)

+              fix MSVC-only compiler problem in code changed in 1.42

+      1.42  (2014-07-09)

+              don't define _CRT_SECURE_NO_WARNINGS (affects user code)

+              fixes to stbi__cleanup_jpeg path

+              added STBI_ASSERT to avoid requiring assert.h

+      1.41  (2014-06-25)

+              fix search&replace from 1.36 that messed up comments/error messages

+      1.40  (2014-06-22)

+              fix gcc struct-initialization warning

+      1.39  (2014-06-15)

+              fix to TGA optimization when req_comp != number of components in TGA;

+              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)

+              add support for BMP version 5 (more ignored fields)

+      1.38  (2014-06-06)

+              suppress MSVC warnings on integer casts truncating values

+              fix accidental rename of 'skip' field of I/O

+      1.37  (2014-06-04)

+              remove duplicate typedef

+      1.36  (2014-06-03)

+              convert to header file single-file library

+              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL

+      1.35  (2014-05-27)

+              various warnings

+              fix broken STBI_SIMD path

+              fix bug where stbi_load_from_file no longer left file pointer in correct place

+              fix broken non-easy path for 32-bit BMP (possibly never used)

+              TGA optimization by Arseny Kapoulkine

+      1.34  (unknown)

+              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case

+      1.33  (2011-07-14)

+              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements

+      1.32  (2011-07-13)

+              support for "info" function for all supported filetypes (SpartanJ)

+      1.31  (2011-06-20)

+              a few more leak fixes, bug in PNG handling (SpartanJ)

+      1.30  (2011-06-11)

+              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)

+              removed deprecated format-specific test/load functions

+              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway

+              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)

+              fix inefficiency in decoding 32-bit BMP (David Woo)

+      1.29  (2010-08-16)

+              various warning fixes from Aurelien Pocheville

+      1.28  (2010-08-01)

+              fix bug in GIF palette transparency (SpartanJ)

+      1.27  (2010-08-01)

+              cast-to-stbi_uc to fix warnings

+      1.26  (2010-07-24)

+              fix bug in file buffering for PNG reported by SpartanJ

+      1.25  (2010-07-17)

+              refix trans_data warning (Won Chun)

+      1.24  (2010-07-12)

+              perf improvements reading from files on platforms with lock-heavy fgetc()

+              minor perf improvements for jpeg

+              deprecated type-specific functions so we'll get feedback if they're needed

+              attempt to fix trans_data warning (Won Chun)

+      1.23    fixed bug in iPhone support

+      1.22  (2010-07-10)

+              removed image *writing* support

+              stbi_info support from Jetro Lauha

+              GIF support from Jean-Marc Lienher

+              iPhone PNG-extensions from James Brown

+              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)

+      1.21    fix use of 'stbi_uc' in header (reported by jon blow)

+      1.20    added support for Softimage PIC, by Tom Seddon

+      1.19    bug in interlaced PNG corruption check (found by ryg)

+      1.18  (2008-08-02)

+              fix a threading bug (local mutable static)

+      1.17    support interlaced PNG

+      1.16    major bugfix - stbi__convert_format converted one too many pixels

+      1.15    initialize some fields for thread safety

+      1.14    fix threadsafe conversion bug

+              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)

+      1.13    threadsafe

+      1.12    const qualifiers in the API

+      1.11    Support installable IDCT, colorspace conversion routines

+      1.10    Fixes for 64-bit (don't use "unsigned long")

+              optimized upsampling by Fabian "ryg" Giesen

+      1.09    Fix format-conversion for PSD code (bad global variables!)

+      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz

+      1.07    attempt to fix C++ warning/errors again

+      1.06    attempt to fix C++ warning/errors again

+      1.05    fix TGA loading to return correct *comp and use good luminance calc

+      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free

+      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR

+      1.02    support for (subset of) HDR files, float interface for preferred access to them

+      1.01    fix bug: possible bug in handling right-side up bmps... not sure

+              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all

+      1.00    interface to zlib that skips zlib header

+      0.99    correct handling of alpha in palette

+      0.98    TGA loader by lonesock; dynamically add loaders (untested)

+      0.97    jpeg errors on too large a file; also catch another malloc failure

+      0.96    fix detection of invalid v value - particleman@mollyrocket forum

+      0.95    during header scan, seek to markers in case of padding

+      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same

+      0.93    handle jpegtran output; verbose errors

+      0.92    read 4,8,16,24,32-bit BMP files of several formats

+      0.91    output 24-bit Windows 3.0 BMP files

+      0.90    fix a few more warnings; bump version number to approach 1.0

+      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd

+      0.60    fix compiling as c++

+      0.59    fix warnings: merge Dave Moore's -Wall fixes

+      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian

+      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available

+      0.56    fix bug: zlib uncompressed mode len vs. nlen

+      0.55    fix bug: restart_interval not initialized to 0

+      0.54    allow NULL for 'int *comp'

+      0.53    fix bug in png 3->4; speedup png decoding

+      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments

+      0.51    obey req_comp requests, 1-component jpegs return as 1-component,

+              on 'test' only check type, not whether we support this variant

+      0.50  (2006-11-19)

+              first released version

+*/

+

+

+/*

+------------------------------------------------------------------------------

+This software is available under 2 licenses -- choose whichever you prefer.

+------------------------------------------------------------------------------

+ALTERNATIVE A - MIT License

+Copyright (c) 2017 Sean Barrett

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

+------------------------------------------------------------------------------

+ALTERNATIVE B - Public Domain (www.unlicense.org)

+This is free and unencumbered software released into the public domain.

+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this

+software, either in source code form or as a compiled binary, for any purpose,

+commercial or non-commercial, and by any means.

+In jurisdictions that recognize copyright laws, the author or authors of this

+software dedicate any and all copyright interest in the software to the public

+domain. We make this dedication for the benefit of the public at large and to

+the detriment of our heirs and successors. We intend this dedication to be an

+overt act of relinquishment in perpetuity of all present and future rights to

+this software under copyright law.

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

+------------------------------------------------------------------------------

+*/

diff --git a/thirdparty/vk_mem_alloc.h b/thirdparty/vk_mem_alloc.h
new file mode 100644
index 0000000..6687871
--- /dev/null
+++ b/thirdparty/vk_mem_alloc.h
@@ -0,0 +1,19229 @@
+//

+// Copyright (c) 2017-2020 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.0-development</b> (2020-11-03)

+

+Copyright (c) 2017-2020 Advanced Micro Devices, Inc. All rights reserved. \n

+License: MIT

+

+Documentation of all members: vk_mem_alloc.h

+

+\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)

+    - [Finding out if memory is mappable](@ref memory_mapping_finding_if_memory_mappable)

+  - \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)

+    - [Buddy allocation algorithm](@ref buddy_algorithm)

+  - \subpage defragmentation

+      - [Defragmenting CPU memory](@ref defragmentation_cpu)

+      - [Defragmenting GPU memory](@ref defragmentation_gpu)

+      - [Additional notes](@ref defragmentation_additional_notes)

+      - [Writing custom allocation algorithm](@ref defragmentation_custom_algorithm)

+  - \subpage lost_allocations

+  - \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 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 record_and_replay

+- \subpage usage_patterns

+  - [Common mistakes](@ref usage_patterns_common_mistakes)

+  - [Simple patterns](@ref usage_patterns_simple)

+  - [Advanced patterns](@ref usage_patterns_advanced)

+- \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)

+  - \subpage vk_khr_dedicated_allocation

+  - \subpage enabling_buffer_device_address

+  - \subpage vk_amd_device_coherent_memory

+- \subpage general_considerations

+  - [Thread safety](@ref general_considerations_thread_safety)

+  - [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)

+

+

+

+

+\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 exacly 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.

+

+Note on language: 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.

+

+Please note that 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.

+

+You may need to configure the way you import Vulkan functions.

+

+- By default, VMA assumes you you link statically with Vulkan API. If this is not the case,

+  `#define VMA_STATIC_VULKAN_FUNCTIONS 0` before `#include` of the VMA implementation and use another way.

+- You can `#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1` and make sure `vkGetInstanceProcAddr` and `vkGetDeviceProcAddr` globals are defined.

+  All the remaining Vulkan functions will be fetched automatically.

+- Finally, you can provide your own pointers to all Vulkan functions needed by VMA using structure member

+  VmaAllocatorCreateInfo::pVulkanFunctions, if you fetched them in some custom way e.g. using some loader like [Volk](https://github.com/zeux/volk).

+

+

+\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().

+

+\code

+VmaAllocatorCreateInfo allocatorInfo = {};

+allocatorInfo.vulkanApiVersion = VK_API_VERSION_1_2;

+allocatorInfo.physicalDevice = physicalDevice;

+allocatorInfo.device = device;

+allocatorInfo.instance = instance;

+

+VmaAllocator allocator;

+vmaCreateAllocator(&allocatorInfo, &allocator);

+\endcode

+

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

+

+

+\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.

+

+\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_GPU_ONLY;

+

+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: vmaFindMemoryTypeIndex(), vmaFindMemoryTypeIndexForBufferInfo(),

+   vmaFindMemoryTypeIndexForImageInfo().

+-# 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().

+-# 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(). This is the easiest and recommended way to use this library.

+

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

+For more details, see description of this enum.

+

+For example, if you want to create a uniform buffer that will be filled using

+transfer only once or infrequently and used for rendering every frame, you can

+do it using following code:

+

+\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_GPU_ONLY;

+

+VkBuffer buffer;

+VmaAllocation allocation;

+vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);

+\endcode

+

+\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_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.

+

+If you use VmaAllocationCreateInfo::usage, it is just internally converted to

+a set of required and preferred flags.

+

+\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's 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:

+

+\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's 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_CPU_ONLY;

+allocCreateInfo.flags = 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

+

+There are some exceptions though, when you should consider mapping memory only for a short period of time:

+

+- When operating system is Windows 7 or 8.x (Windows 10 is not affected because it uses WDDM2),

+  device is discrete AMD GPU,

+  and memory type is the special 256 MiB pool of `DEVICE_LOCAL + HOST_VISIBLE` memory

+  (selected when you use #VMA_MEMORY_USAGE_CPU_TO_GPU),

+  then whenever a memory block allocated from this memory type stays mapped

+  for the time of any call to `vkQueueSubmit()` or `vkQueuePresentKHR()`, this

+  block is migrated by WDDM to system RAM, which degrades performance. It doesn't

+  matter if that particular memory block is actually used by the command buffer

+  being submitted.

+- On Mac/MoltenVK there is a known bug - [Issue #175](https://github.com/KhronosGroup/MoltenVK/issues/175)

+  which requires unmapping before GPU can see updated texture.

+- Keeping many large memory blocks mapped may impact performance or stability of some debugging tools.

+

+\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.

+

+Please note that memory allocated with #VMA_MEMORY_USAGE_CPU_ONLY is guaranteed to be `HOST_COHERENT`.

+

+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 this platform you may not need to bother.

+

+\section memory_mapping_finding_if_memory_mappable Finding out if memory is mappable

+

+It may happen that your allocation ends up in memory that is `HOST_VISIBLE` (available for mapping)

+despite it wasn't explicitly requested.

+For example, application may work on integrated graphics with unified memory (like Intel) or

+allocation from video memory might have failed, so the library chose system memory as fallback.

+

+You can detect this case and map such allocation to access its memory on CPU directly,

+instead of launching a transfer operation.

+In order to do that: inspect `allocInfo.memoryType`, call vmaGetMemoryTypeProperties(),

+and look for `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` flag in properties of that memory type.

+

+\code

+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };

+bufCreateInfo.size = sizeof(ConstantBuffer);

+bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

+

+VmaAllocationCreateInfo allocCreateInfo = {};

+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;

+allocCreateInfo.preferredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;

+

+VkBuffer buf;

+VmaAllocation alloc;

+VmaAllocationInfo allocInfo;

+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

+

+VkMemoryPropertyFlags memFlags;

+vmaGetMemoryTypeProperties(allocator, allocInfo.memoryType, &memFlags);

+if((memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)

+{

+    // Allocation ended up in mappable memory. You can map it and access it directly.

+    void* mappedData;

+    vmaMapMemory(allocator, alloc, &mappedData);

+    memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));

+    vmaUnmapMemory(allocator, alloc);

+}

+else

+{

+    // Allocation ended up in non-mappable memory.

+    // You need to create CPU-side buffer in VMA_MEMORY_USAGE_CPU_ONLY and make a transfer.

+}

+\endcode

+

+You can even use #VMA_ALLOCATION_CREATE_MAPPED_BIT flag while creating allocations

+that are not necessarily `HOST_VISIBLE` (e.g. using #VMA_MEMORY_USAGE_GPU_ONLY).

+If the allocation ends up in memory type that is `HOST_VISIBLE`, it will be persistently mapped and you can use it directly.

+If not, the flag is just ignored.

+Example:

+

+\code

+VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };

+bufCreateInfo.size = sizeof(ConstantBuffer);

+bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;

+

+VmaAllocationCreateInfo allocCreateInfo = {};

+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;

+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;

+

+VkBuffer buf;

+VmaAllocation alloc;

+VmaAllocationInfo allocInfo;

+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

+

+if(allocInfo.pMappedData != nullptr)

+{

+    // Allocation ended up in mappable memory.

+    // It's persistently mapped. You can access it directly.

+    memcpy(allocInfo.pMappedData, &constantBufferData, sizeof(constantBufferData));

+}

+else

+{

+    // Allocation ended up in non-mappable memory.

+    // You need to create CPU-side buffer in VMA_MEMORY_USAGE_CPU_ONLY and make a transfer.

+}

+\endcode

+

+

+\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's 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 vmaGetBudget().

+Returned structure #VmaBudget contains quantities expressed in bytes, per Vulkan memory heap.

+

+Please note that this function returns different information and works faster than

+vmaCalculateStats(). vmaGetBudget() can be called every frame or even before every

+allocation, while vmaCalculateStats() 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.

+Some other allocations become lost instead to make room for it, if the mechanism of

+[lost allocations](@ref lost_allocations) is used.

+If that is not possible, the allocation 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).

+

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

+

+Please note that creating \ref custom_memory_pools with VmaPoolCreateInfo::minBlockCount

+set to more than 0 will 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.usage = VMA_MEMORY_USAGE_GPU_ONLY;

+

+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 resouces 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 of 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.

+

+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

+// Create a pool that can have at most 2 blocks, 128 MiB each.

+VmaPoolCreateInfo poolCreateInfo = {};

+poolCreateInfo.memoryTypeIndex = ...

+poolCreateInfo.blockSize = 128ull * 1024 * 1024;

+poolCreateInfo.maxBlockCount = 2;

+

+VmaPool pool;

+vmaCreatePool(allocator, &poolCreateInfo, &pool);

+

+// 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;

+VmaAllocationInfo allocInfo;

+vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

+\endcode

+

+You have to free all allocations made from this pool before destroying it.

+

+\code

+vmaDestroyBuffer(allocator, buf, alloc);

+vmaDestroyPool(allocator, pool);

+\endcode

+

+\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; // Whatever.

+exampleBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; // Change if needed.

+

+VmaAllocationCreateInfo allocCreateInfo = {};

+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; // Change if needed.

+

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

+

+\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 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)

+

+Pools with linear algorithm support [lost allocations](@ref lost_allocations) when used as ring buffer.

+If there is not enough free space for a new allocation, but existing allocations

+from the front of the queue can become lost, they become lost and the allocation

+succeeds.

+

+![Ring buffer with lost allocations](../gfx/Linear_allocator_6_ring_buffer_lost.png)

+

+Ring buffer is available only in pools with one memory block -

+VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.

+

+\section buddy_algorithm Buddy allocation algorithm

+

+There is another allocation algorithm that can be used with custom pools, called

+"buddy". Its internal data structure is based on a tree of blocks, each having

+size that is a power of two and a half of its parent's size. When you want to

+allocate memory of certain size, a free node in the tree is located. If it's too

+large, it is recursively split into two halves (called "buddies"). However, if

+requested allocation size is not a power of two, the size of a tree node is

+aligned up to the nearest power of two and the remaining space is wasted. When

+two buddy nodes become free, they are merged back into one larger node.

+

+![Buddy allocator](../gfx/Buddy_allocator.png)

+

+The advantage of buddy allocation algorithm over default algorithm is faster

+allocation and deallocation, as well as smaller external fragmentation. The

+disadvantage is more wasted space (internal fragmentation).

+

+For more information, please read ["Buddy memory allocation" on Wikipedia](https://en.wikipedia.org/wiki/Buddy_memory_allocation)

+or other sources that describe this concept in general.

+

+To use buddy allocation algorithm with a custom pool, add flag

+#VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT to VmaPoolCreateInfo::flags while creating

+#VmaPool object.

+

+Several limitations apply to pools that use buddy algorithm:

+

+- It is recommended to use VmaPoolCreateInfo::blockSize that is a power of two.

+  Otherwise, only largest power of two smaller than the size is used for

+  allocations. The remaining space always stays unused.

+- [Margins](@ref debugging_memory_usage_margins) and

+  [corruption detection](@ref debugging_memory_usage_corruption_detection)

+  don't work in such pools.

+- [Lost allocations](@ref lost_allocations) don't work in such pools. You can

+  use them, but they never become lost. Support may be added in the future.

+- [Defragmentation](@ref defragmentation) doesn't work with allocations made from

+  such pool.

+

+\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:

+structure #VmaDefragmentationInfo2, function vmaDefragmentationBegin(), vmaDefragmentationEnd().

+Given set of allocations,

+this function can move them to compact used memory, ensure more continuous free

+space and possibly also free some `VkDeviceMemory` blocks.

+

+What the defragmentation does is:

+

+- Updates #VmaAllocation objects to point to new `VkDeviceMemory` and offset.

+  After allocation has been moved, its VmaAllocationInfo::deviceMemory and/or

+  VmaAllocationInfo::offset changes. You must query them again using

+  vmaGetAllocationInfo() if you need them.

+- Moves actual data in memory.

+

+What it doesn't do, so you need to do it yourself:

+

+- Recreate buffers and images that were bound to allocations that were defragmented and

+  bind them with their new places in memory.

+  You must use `vkDestroyBuffer()`, `vkDestroyImage()`,

+  `vkCreateBuffer()`, `vkCreateImage()`, vmaBindBufferMemory(), vmaBindImageMemory()

+  for that purpose and NOT vmaDestroyBuffer(),

+  vmaDestroyImage(), vmaCreateBuffer(), vmaCreateImage(), because you don't need to

+  destroy or create allocation objects!

+- Recreate views and update descriptors that point to these buffers and images.

+

+\section defragmentation_cpu Defragmenting CPU memory

+

+Following example demonstrates how you can run defragmentation on CPU.

+Only allocations created in memory types that are `HOST_VISIBLE` can be defragmented.

+Others are ignored.

+

+The way it works is:

+

+- It temporarily maps entire memory blocks when necessary.

+- It moves data using `memmove()` function.

+

+\code

+// Given following variables already initialized:

+VkDevice device;

+VmaAllocator allocator;

+std::vector<VkBuffer> buffers;

+std::vector<VmaAllocation> allocations;

+

+

+const uint32_t allocCount = (uint32_t)allocations.size();

+std::vector<VkBool32> allocationsChanged(allocCount);

+

+VmaDefragmentationInfo2 defragInfo = {};

+defragInfo.allocationCount = allocCount;

+defragInfo.pAllocations = allocations.data();

+defragInfo.pAllocationsChanged = allocationsChanged.data();

+defragInfo.maxCpuBytesToMove = VK_WHOLE_SIZE; // No limit.

+defragInfo.maxCpuAllocationsToMove = UINT32_MAX; // No limit.

+

+VmaDefragmentationContext defragCtx;

+vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);

+vmaDefragmentationEnd(allocator, defragCtx);

+

+for(uint32_t i = 0; i < allocCount; ++i)

+{

+    if(allocationsChanged[i])

+    {

+        // Destroy buffer that is immutably bound to memory region which is no longer valid.

+        vkDestroyBuffer(device, buffers[i], nullptr);

+

+        // Create new buffer with same parameters.

+        VkBufferCreateInfo bufferInfo = ...;

+        vkCreateBuffer(device, &bufferInfo, nullptr, &buffers[i]);

+

+        // You can make dummy call to vkGetBufferMemoryRequirements here to silence validation layer warning.

+

+        // Bind new buffer to new memory region. Data contained in it is already moved.

+        VmaAllocationInfo allocInfo;

+        vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);

+        vmaBindBufferMemory(allocator, allocations[i], buffers[i]);

+    }

+}

+\endcode

+

+Setting VmaDefragmentationInfo2::pAllocationsChanged is optional.

+This output array tells whether particular allocation in VmaDefragmentationInfo2::pAllocations at the same index

+has been modified during defragmentation.

+You can pass null, but you then need to query every allocation passed to defragmentation

+for new parameters using vmaGetAllocationInfo() if you might need to recreate and rebind a buffer or image associated with it.

+

+If you use [Custom memory pools](@ref choosing_memory_type_custom_memory_pools),

+you can fill VmaDefragmentationInfo2::poolCount and VmaDefragmentationInfo2::pPools

+instead of VmaDefragmentationInfo2::allocationCount and VmaDefragmentationInfo2::pAllocations

+to defragment all allocations in given pools.

+You cannot use VmaDefragmentationInfo2::pAllocationsChanged in that case.

+You can also combine both methods.

+

+\section defragmentation_gpu Defragmenting GPU memory

+

+It is also possible to defragment allocations created in memory types that are not `HOST_VISIBLE`.

+To do that, you need to pass a command buffer that meets requirements as described in

+VmaDefragmentationInfo2::commandBuffer. The way it works is:

+

+- It creates temporary buffers and binds them to entire memory blocks when necessary.

+- It issues `vkCmdCopyBuffer()` to passed command buffer.

+

+Example:

+

+\code

+// Given following variables already initialized:

+VkDevice device;

+VmaAllocator allocator;

+VkCommandBuffer commandBuffer;

+std::vector<VkBuffer> buffers;

+std::vector<VmaAllocation> allocations;

+

+

+const uint32_t allocCount = (uint32_t)allocations.size();

+std::vector<VkBool32> allocationsChanged(allocCount);

+

+VkCommandBufferBeginInfo cmdBufBeginInfo = ...;

+vkBeginCommandBuffer(commandBuffer, &cmdBufBeginInfo);

+

+VmaDefragmentationInfo2 defragInfo = {};

+defragInfo.allocationCount = allocCount;

+defragInfo.pAllocations = allocations.data();

+defragInfo.pAllocationsChanged = allocationsChanged.data();

+defragInfo.maxGpuBytesToMove = VK_WHOLE_SIZE; // Notice it's "GPU" this time.

+defragInfo.maxGpuAllocationsToMove = UINT32_MAX; // Notice it's "GPU" this time.

+defragInfo.commandBuffer = commandBuffer;

+

+VmaDefragmentationContext defragCtx;

+vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);

+

+vkEndCommandBuffer(commandBuffer);

+

+// Submit commandBuffer.

+// Wait for a fence that ensures commandBuffer execution finished.

+

+vmaDefragmentationEnd(allocator, defragCtx);

+

+for(uint32_t i = 0; i < allocCount; ++i)

+{

+    if(allocationsChanged[i])

+    {

+        // Destroy buffer that is immutably bound to memory region which is no longer valid.

+        vkDestroyBuffer(device, buffers[i], nullptr);

+

+        // Create new buffer with same parameters.

+        VkBufferCreateInfo bufferInfo = ...;

+        vkCreateBuffer(device, &bufferInfo, nullptr, &buffers[i]);

+

+        // You can make dummy call to vkGetBufferMemoryRequirements here to silence validation layer warning.

+

+        // Bind new buffer to new memory region. Data contained in it is already moved.

+        VmaAllocationInfo allocInfo;

+        vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);

+        vmaBindBufferMemory(allocator, allocations[i], buffers[i]);

+    }

+}

+\endcode

+

+You can combine these two methods by specifying non-zero `maxGpu*` as well as `maxCpu*` parameters.

+The library automatically chooses best method to defragment each memory pool.

+

+You may try not to block your entire program to wait until defragmentation finishes,

+but do it in the background, as long as you carefully fullfill requirements described

+in function vmaDefragmentationBegin().

+

+\section defragmentation_additional_notes Additional notes

+

+It is only legal to defragment allocations bound to:

+

+- buffers

+- images created with `VK_IMAGE_CREATE_ALIAS_BIT`, `VK_IMAGE_TILING_LINEAR`, and

+  being currently in `VK_IMAGE_LAYOUT_GENERAL` or `VK_IMAGE_LAYOUT_PREINITIALIZED`.

+

+Defragmentation of images created with `VK_IMAGE_TILING_OPTIMAL` or in any other

+layout may give undefined results.

+

+If you defragment allocations bound to images, new images to be bound to new

+memory region after defragmentation should be created with `VK_IMAGE_LAYOUT_PREINITIALIZED`

+and then transitioned to their original layout from before defragmentation if

+needed using an image memory barrier.

+

+While using defragmentation, you may experience validation layer warnings, which you just need to ignore.

+See [Validation layer warnings](@ref general_considerations_validation_layer_warnings).

+

+Please don't expect memory to be fully compacted after defragmentation.

+Algorithms inside are based on some heuristics that try to maximize number of Vulkan

+memory blocks to make totally empty to release them, as well as to maximimze continuous

+empty space inside remaining blocks, while minimizing the number and size of allocations that

+need to be moved. Some fragmentation may still remain - this is normal.

+

+\section defragmentation_custom_algorithm Writing custom defragmentation algorithm

+

+If you want to implement your own, custom defragmentation algorithm,

+there is infrastructure prepared for that,

+but it is not exposed through the library API - you need to hack its source code.

+Here are steps needed to do this:

+

+-# Main thing you need to do is to define your own class derived from base abstract

+   class `VmaDefragmentationAlgorithm` and implement your version of its pure virtual methods.

+   See definition and comments of this class for details.

+-# Your code needs to interact with device memory block metadata.

+   If you need more access to its data than it's provided by its public interface,

+   declare your new class as a friend class e.g. in class `VmaBlockMetadata_Generic`.

+-# If you want to create a flag that would enable your algorithm or pass some additional

+   flags to configure it, add them to `VmaDefragmentationFlagBits` and use them in

+   VmaDefragmentationInfo2::flags.

+-# Modify function `VmaBlockVectorDefragmentationContext::Begin` to create object

+   of your new class whenever needed.

+

+

+\page lost_allocations Lost allocations

+

+If your game oversubscribes video memory, if may work OK in previous-generation

+graphics APIs (DirectX 9, 10, 11, OpenGL) because resources are automatically

+paged to system RAM. In Vulkan you can't do it because when you run out of

+memory, an allocation just fails. If you have more data (e.g. textures) that can

+fit into VRAM and you don't need it all at once, you may want to upload them to

+GPU on demand and "push out" ones that are not used for a long time to make room

+for the new ones, effectively using VRAM (or a cartain memory pool) as a form of

+cache. Vulkan Memory Allocator can help you with that by supporting a concept of

+"lost allocations".

+

+To create an allocation that can become lost, include #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT

+flag in VmaAllocationCreateInfo::flags. Before using a buffer or image bound to

+such allocation in every new frame, you need to query it if it's not lost.

+To check it, call vmaTouchAllocation().

+If the allocation is lost, you should not use it or buffer/image bound to it.

+You mustn't forget to destroy this allocation and this buffer/image.

+vmaGetAllocationInfo() can also be used for checking status of the allocation.

+Allocation is lost when returned VmaAllocationInfo::deviceMemory == `VK_NULL_HANDLE`.

+

+To create an allocation that can make some other allocations lost to make room

+for it, use #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flag. You will

+usually use both flags #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT and

+#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT at the same time.

+

+Warning! Current implementation uses quite naive, brute force algorithm,

+which can make allocation calls that use #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT

+flag quite slow. A new, more optimal algorithm and data structure to speed this

+up is planned for the future.

+

+<b>Q: When interleaving creation of new allocations with usage of existing ones,

+how do you make sure that an allocation won't become lost while it's used in the

+current frame?</b>

+

+It is ensured because vmaTouchAllocation() / vmaGetAllocationInfo() not only returns allocation

+status/parameters and checks whether it's not lost, but when it's not, it also

+atomically marks it as used in the current frame, which makes it impossible to

+become lost in that frame. It uses lockless algorithm, so it works fast and

+doesn't involve locking any internal mutex.

+

+<b>Q: What if my allocation may still be in use by the GPU when it's rendering a

+previous frame while I already submit new frame on the CPU?</b>

+

+You can make sure that allocations "touched" by vmaTouchAllocation() / vmaGetAllocationInfo() will not

+become lost for a number of additional frames back from the current one by

+specifying this number as VmaAllocatorCreateInfo::frameInUseCount (for default

+memory pool) and VmaPoolCreateInfo::frameInUseCount (for custom pool).

+

+<b>Q: How do you inform the library when new frame starts?</b>

+

+You need to call function vmaSetCurrentFrameIndex().

+

+Example code:

+

+\code

+struct MyBuffer

+{

+    VkBuffer m_Buf = nullptr;

+    VmaAllocation m_Alloc = nullptr;

+

+    // Called when the buffer is really needed in the current frame.

+    void EnsureBuffer();

+};

+

+void MyBuffer::EnsureBuffer()

+{

+    // Buffer has been created.

+    if(m_Buf != VK_NULL_HANDLE)

+    {

+        // Check if its allocation is not lost + mark it as used in current frame.

+        if(vmaTouchAllocation(allocator, m_Alloc))

+        {

+            // It's all OK - safe to use m_Buf.

+            return;

+        }

+    }

+

+    // Buffer not yet exists or lost - destroy and recreate it.

+

+    vmaDestroyBuffer(allocator, m_Buf, m_Alloc);

+

+    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.usage = VMA_MEMORY_USAGE_GPU_ONLY;

+    allocCreateInfo.flags = VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT |

+        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;

+

+    vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &m_Buf, &m_Alloc, nullptr);

+}

+\endcode

+

+When using lost allocations, you may see some Vulkan validation layer warnings

+about overlapping regions of memory bound to different kinds of buffers and

+images. This is still valid as long as you implement proper handling of lost

+allocations (like in the example above) and don't use them.

+

+You can create an allocation that is already in lost state from the beginning using function

+vmaCreateLostAllocation(). It may be useful if you need a "dummy" allocation that is not null.

+

+You can call function vmaMakePoolAllocationsLost() to set all eligible allocations

+in a specified custom pool to lost state.

+Allocations that have been "touched" in current frame or VmaPoolCreateInfo::frameInUseCount frames back

+cannot become lost.

+

+<b>Q: Can I touch allocation that cannot become lost?</b>

+

+Yes, although it has no visible effect.

+Calls to vmaGetAllocationInfo() and vmaTouchAllocation() update last use frame index

+also for allocations that cannot become lost, but the only way to observe it is to dump

+internal allocator state using vmaBuildStatsString().

+You can use this feature for debugging purposes to explicitly mark allocations that you use

+in current frame and then analyze JSON dump to see for how long each allocation stays unused.

+

+

+\page statistics Statistics

+

+This library contains functions that return information about its internal state,

+especially the amount of memory allocated from Vulkan.

+Please keep in mind that these functions need to traverse all internal data structures

+to gather these information, so they may be quite time-consuming.

+Don't call them too often.

+

+\section statistics_numeric_statistics Numeric statistics

+

+You can query for overall statistics of the allocator using function vmaCalculateStats().

+Information are returned using structure #VmaStats.

+It contains #VmaStatInfo - number of allocated blocks, number of allocations

+(occupied ranges in these blocks), number of unused (free) ranges in these blocks,

+number of bytes used and unused (but still allocated from Vulkan) and other information.

+They are summed across memory heaps, memory types and total for whole allocator.

+

+You can query for statistics of a custom pool using function vmaGetPoolStats().

+Information are returned using structure #VmaPoolStats.

+

+You can query for information about 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 vmaCalculateStats().

+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's 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.

+

+\code

+VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };

+// Fill bufferInfo...

+

+MyBufferMetadata* pMetadata = CreateBufferMetadata();

+

+VmaAllocationCreateInfo allocCreateInfo = {};

+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;

+allocCreateInfo.pUserData = pMetadata;

+

+VkBuffer buffer;

+VmaAllocation allocation;

+vmaCreateBuffer(allocator, &bufferInfo, &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

+

+There is alternative mode available where `pUserData` pointer is used to point to

+a null-terminated string, giving a name to the allocation. To use this mode,

+set #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT flag in VmaAllocationCreateInfo::flags.

+Then `pUserData` passed as VmaAllocationCreateInfo::pUserData or argument to

+vmaSetAllocationUserData() must be either null or pointer to a null-terminated string.

+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

+VkImageCreateInfo imageInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };

+// Fill imageInfo...

+

+std::string imageName = "Texture: ";

+imageName += fileName;

+

+VmaAllocationCreateInfo allocCreateInfo = {};

+allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;

+allocCreateInfo.flags = VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT;

+allocCreateInfo.pUserData = imageName.c_str();

+

+VkImage image;

+VmaAllocation allocation;

+vmaCreateImage(allocator, &imageInfo, &allocCreateInfo, &image, &allocation, nullptr);

+\endcode

+

+The value of `pUserData` pointer of the allocation will be different than the one

+you passed when setting allocation's name - pointing to a buffer managed

+internally that holds copy of the string.

+

+\code

+VmaAllocationInfo allocInfo;

+vmaGetAllocationInfo(allocator, allocation, &allocInfo);

+const char* imageName = (const char*)allocInfo.pUserData;

+printf("Image name: %s\n", imageName);

+\endcode

+

+That string is also printed in JSON report created by vmaBuildStatsString().

+

+\note Passing 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 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 all 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`.

+It works also with dedicated allocations.

+It doesn't work with allocations created with #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,

+as they cannot be mapped.

+

+\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 before and 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.

+

+The margin is applied also before first and after last allocation in a block.

+It may occur only once between two adjacent allocations.

+

+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 are also not active in custom pools created with #VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT flag.

+

+Margins appear in [JSON dump](@ref statistics_json_dump) as part of free space.

+

+Note that enabling margins increases memory usage and fragmentation.

+

+\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) before and 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's 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 record_and_replay Record and replay

+

+\section record_and_replay_introduction Introduction

+

+While using the library, sequence of calls to its functions together with their

+parameters can be recorded to a file and later replayed using standalone player

+application. It can be useful to:

+

+- Test correctness - check if same sequence of calls will not cause crash or

+  failures on a target platform.

+- Gather statistics - see number of allocations, peak memory usage, number of

+  calls etc.

+- Benchmark performance - see how much time it takes to replay the whole

+  sequence.

+

+\section record_and_replay_usage Usage

+

+Recording functionality is disabled by default.

+To enable it, define following macro before every include of this library:

+

+\code

+#define VMA_RECORDING_ENABLED 1

+\endcode

+

+<b>To record sequence of calls to a file:</b> Fill in

+VmaAllocatorCreateInfo::pRecordSettings member while creating #VmaAllocator

+object. File is opened and written during whole lifetime of the allocator.

+

+<b>To replay file:</b> Use VmaReplay - standalone command-line program.

+Precompiled binary can be found in "bin" directory.

+Its source can be found in "src/VmaReplay" directory.

+Its project is generated by Premake.

+Command line syntax is printed when the program is launched without parameters.

+Basic usage:

+

+    VmaReplay.exe MyRecording.csv

+

+<b>Documentation of file format</b> can be found in file: "docs/Recording file format.md".

+It's a human-readable, text file in CSV format (Comma Separated Values).

+

+\section record_and_replay_additional_considerations Additional considerations

+

+- Replaying file that was recorded on a different GPU (with different parameters

+  like `bufferImageGranularity`, `nonCoherentAtomSize`, and especially different

+  set of memory heaps and types) may give different performance and memory usage

+  results, as well as issue some warnings and errors.

+- Current implementation of recording in VMA, as well as VmaReplay application, is

+  coded and tested only on Windows. Inclusion of recording code is driven by

+  `VMA_RECORDING_ENABLED` macro. Support for other platforms should be easy to

+  add. Contributions are welcomed.

+

+

+\page usage_patterns Recommended usage 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_common_mistakes Common mistakes

+

+<b>Use of CPU_TO_GPU instead of CPU_ONLY memory</b>

+

+#VMA_MEMORY_USAGE_CPU_TO_GPU is recommended only for resources that will be

+mapped and written by the CPU, as well as read directly by the GPU - like some

+buffers or textures updated every frame (dynamic). If you create a staging copy

+of a resource to be written by CPU and then used as a source of transfer to

+another resource placed in the GPU memory, that staging resource should be

+created with #VMA_MEMORY_USAGE_CPU_ONLY. Please read the descriptions of these

+enums carefully for details.

+

+<b>Unnecessary use of custom pools</b>

+

+\ref custom_memory_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, limit maximum amount of memory they can occupy, or make some of them

+push out the other through the mechanism of \ref lost_allocations. 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 usage_patterns_simple Simple patterns

+

+\subsection usage_patterns_simple_render_targets Render targets

+

+<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>

+Create them in video memory that is fastest to access from GPU using

+#VMA_MEMORY_USAGE_GPU_ONLY.

+

+Consider using [VK_KHR_dedicated_allocation](@ref vk_khr_dedicated_allocation) extension

+and/or manually 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 e.g. when

+display resolution changes.

+Prefer to create such resources first and all other GPU resources (like textures and vertex buffers) later.

+

+\subsection usage_patterns_simple_immutable_resources Immutable resources

+

+<b>When:</b>

+Any resources that you fill on CPU only once (aka "immutable") or infrequently

+and then read frequently on GPU,

+e.g. textures, vertex and index buffers, constant buffers that don't change often.

+

+<b>What to do:</b>

+Create them in video memory that is fastest to access from GPU using

+#VMA_MEMORY_USAGE_GPU_ONLY.

+

+To initialize content of such resource, create a CPU-side (aka "staging") copy of it

+in system memory - #VMA_MEMORY_USAGE_CPU_ONLY, map it, fill it,

+and submit a transfer from it to the GPU resource.

+You can keep the staging copy if you need it for another upload transfer in the future.

+If you don't, you can destroy it or reuse this buffer for uploading different resource

+after the transfer finishes.

+

+Prefer to create just buffers in system memory rather than images, even for uploading textures.

+Use `vkCmdCopyBufferToImage()`.

+Dont use images with `VK_IMAGE_TILING_LINEAR`.

+

+\subsection usage_patterns_dynamic_resources Dynamic resources

+

+<b>When:</b>

+Any resources that change frequently (aka "dynamic"), e.g. every frame or every draw call,

+written on CPU, read on GPU.

+

+<b>What to do:</b>

+Create them using #VMA_MEMORY_USAGE_CPU_TO_GPU.

+You can map it and write to it directly on CPU, as well as read from it on GPU.

+

+This is a more complex situation. Different solutions are possible,

+and the best one depends on specific GPU type, but you can use this simple approach for the start.

+Prefer to write to such resource sequentially (e.g. using `memcpy`).

+Don't perform random access or any reads from it on CPU, as it may be very slow.

+Also note that textures written directly from the host through a mapped pointer need to be in LINEAR not OPTIMAL layout.

+

+\subsection usage_patterns_readback Readback

+

+<b>When:</b>

+Resources that contain data written by GPU that you want to read back on CPU,

+e.g. results of some computations.

+

+<b>What to do:</b>

+Create them using #VMA_MEMORY_USAGE_GPU_TO_CPU.

+You can write to them directly on GPU, as well as map and read them on CPU.

+

+\section usage_patterns_advanced Advanced patterns

+

+\subsection usage_patterns_integrated_graphics Detecting integrated graphics

+

+You can support integrated graphics (like Intel HD Graphics, AMD APU) better

+by detecting it in Vulkan.

+To do it, call `vkGetPhysicalDeviceProperties()`, inspect

+`VkPhysicalDeviceProperties::deviceType` and look for `VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU`.

+When you find it, you can assume that memory is unified and all memory types are comparably fast

+to access from GPU, regardless of `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`.

+

+You can then sum up sizes of all available memory heaps and treat them as useful for

+your GPU resources, instead of only `DEVICE_LOCAL` ones.

+You can also prefer to create your resources in memory types that are `HOST_VISIBLE` to map them

+directly instead of submitting explicit transfer (see below).

+

+\subsection usage_patterns_direct_vs_transfer Direct access versus transfer

+

+For resources that you frequently write on CPU and read on GPU, many solutions are possible:

+

+-# Create one copy in video memory using #VMA_MEMORY_USAGE_GPU_ONLY,

+   second copy in system memory using #VMA_MEMORY_USAGE_CPU_ONLY and submit explicit transfer each time.

+-# Create just a single copy using #VMA_MEMORY_USAGE_CPU_TO_GPU, map it and fill it on CPU,

+   read it directly on GPU.

+-# Create just a single copy using #VMA_MEMORY_USAGE_CPU_ONLY, map it and fill it on CPU,

+   read it directly on GPU.

+

+Which solution is the most efficient depends on your resource and especially on the GPU.

+It is best to measure it and then make the decision.

+Some general recommendations:

+

+- On integrated graphics use (2) or (3) to avoid unnecesary time and memory overhead

+  related to using a second copy and making transfer.

+- For small resources (e.g. constant buffers) use (2).

+  Discrete AMD cards have special 256 MiB pool of video memory that is directly mappable.

+  Even if the resource ends up in system memory, its data may be cached on GPU after first

+  fetch over PCIe bus.

+- For larger resources (e.g. textures), decide between (1) and (2).

+  You may want to differentiate NVIDIA and AMD, e.g. by looking for memory type that is

+  both `DEVICE_LOCAL` and `HOST_VISIBLE`. When you find it, use (2), otherwise use (1).

+

+Similarly, for resources that you frequently write on GPU and read on CPU, multiple

+solutions are possible:

+

+-# Create one copy in video memory using #VMA_MEMORY_USAGE_GPU_ONLY,

+   second copy in system memory using #VMA_MEMORY_USAGE_GPU_TO_CPU and submit explicit tranfer each time.

+-# Create just single copy using #VMA_MEMORY_USAGE_GPU_TO_CPU, write to it directly on GPU,

+   map it and read it on CPU.

+

+You should take some measurements to decide which option is faster in case of your specific

+resource.

+

+Note that textures accessed directly from the host through a mapped pointer need to be in LINEAR layout,

+which may slow down their usage on the device.

+Textures accessed only by the device and transfer operations can use OPTIMAL layout.

+

+If you don't want to specialize your code for specific types of GPUs, you can still make

+an simple optimization for cases when your resource ends up in mappable memory to use it

+directly in this case instead of creating CPU-side staging copy.

+For details see [Finding out if memory is mappable](@ref memory_mapping_finding_if_memory_mappable).

+

+

+\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.

+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. To enable it:

+

+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's 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/chap44.html#VK_KHR_dedicated_allocation)

+- [VK_KHR_dedicated_allocation unofficial manual](http://asawicki.info/articles/VK_KHR_dedicated_allocation.php5)

+

+

+

+\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_COHERENT_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/html/chap44.html#VK_AMD_device_coherent_memory)

+

+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 is 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.

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

+

+\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 happens when you use lost allocations, and a new image or buffer is

+    created in place of an existing object that bacame lost.

+  - It may happen also 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 and #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flag was

+   specified, try to find space in existing blocks, possilby making some other

+   allocations lost.

+-# 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 (straming) 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.

+- Allocations for imported/exported external memory. They tend to require

+  explicit memory type index and dedicated allocation anyway, so they don't

+  interact with main features of this library. Such special purpose allocations

+  should be made manually, using `vkCreateBuffer()` and `vkAllocateMemory()`.

+- Sub-allocation of parts of one large buffer. Although recommended as a good practice,

+  it is the user's responsibility to implement such logic on top of VMA.

+- 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's 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.

+- This is a C++ library with C interface.

+  Bindings or ports to any other programming languages are welcomed as external projects and

+  are not going to be included into this repository.

+

+*/

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/*

+Define this macro to 0/1 to disable/enable support for recording functionality,

+available through VmaAllocatorCreateInfo::pRecordSettings.

+*/

+#ifndef VMA_RECORDING_ENABLED

+    #define VMA_RECORDING_ENABLED 0

+#endif

+

+#if !defined(NOMINMAX) && defined(VMA_IMPLEMENTATION)

+    #define NOMINMAX // For windows.h

+#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

+

+#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_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(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

+

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

+

+/** \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)

+

+/// 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;

+

+/// 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's `VK_API_VERSION_1_1`, the flag is ignored because the extension has been promoted to Vulkan 1.1.

+

+    Using this extenion 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's `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,

+

+    VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

+} VmaAllocatorCreateFlagBits;

+typedef VkFlags VmaAllocatorCreateFlags;

+

+/** \brief Pointers to some Vulkan functions - a subset used by the library.

+

+Used in VmaAllocatorCreateInfo::pVulkanFunctions.

+*/

+typedef struct VmaVulkanFunctions {

+    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

+    PFN_vkGetBufferMemoryRequirements2KHR VMA_NULLABLE vkGetBufferMemoryRequirements2KHR;

+    PFN_vkGetImageMemoryRequirements2KHR VMA_NULLABLE vkGetImageMemoryRequirements2KHR;

+#endif

+#if VMA_BIND_MEMORY2 || VMA_VULKAN_VERSION >= 1001000

+    PFN_vkBindBufferMemory2KHR VMA_NULLABLE vkBindBufferMemory2KHR;

+    PFN_vkBindImageMemory2KHR VMA_NULLABLE vkBindImageMemory2KHR;

+#endif

+#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000

+    PFN_vkGetPhysicalDeviceMemoryProperties2KHR VMA_NULLABLE vkGetPhysicalDeviceMemoryProperties2KHR;

+#endif

+} VmaVulkanFunctions;

+

+/// Flags to be used in VmaRecordSettings::flags.

+typedef enum VmaRecordFlagBits {

+    /** \brief Enables flush after recording every function call.

+

+    Enable it if you expect your application to crash, which may leave recording file truncated.

+    It may degrade performance though.

+    */

+    VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001,

+

+    VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

+} VmaRecordFlagBits;

+typedef VkFlags VmaRecordFlags;

+

+/// Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings.

+typedef struct VmaRecordSettings

+{

+    /// Flags for recording. Use #VmaRecordFlagBits enum.

+    VmaRecordFlags flags;

+    /** \brief Path to the file that should be written by the recording.

+

+    Suggested extension: "csv".

+    If the file already exists, it will be overwritten.

+    It will be opened for the whole time #VmaAllocator object is alive.

+    If opening this file fails, creation of the whole allocator object fails.

+    */

+    const char* VMA_NOT_NULL pFilePath;

+} VmaRecordSettings;

+

+/// 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 Maximum number of additional frames that are in use at the same time as current frame.

+

+    This value is used only when you make allocations with

+    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocation cannot become

+    lost if allocation.lastUseFrameIndex >= allocator.currentFrameIndex - frameInUseCount.

+

+    For example, if you double-buffer your command buffers, so resources used for

+    rendering in previous frame may still be in use by the GPU at the moment you

+    allocate resources needed for the current frame, set this value to 1.

+

+    If you want to allow any allocations other than used in the current frame to

+    become lost, set this value to 0.

+    */

+    uint32_t frameInUseCount;

+    /** \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 Parameters for recording of VMA calls. Can be null.

+

+    If not null, it enables recording of calls to VMA functions to a file.

+    If support for recording is not enabled using `VMA_RECORDING_ENABLED` macro,

+    creation of the allocator object fails with `VK_ERROR_FEATURE_NOT_PRESENT`.

+    */

+    const VmaRecordSettings* VMA_NULLABLE pRecordSettings;

+    /** \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 are supported by the current implementation.

+    Leaving it initialized to zero is equivalent to `VK_API_VERSION_1_0`.

+    */

+    uint32_t vulkanApiVersion;

+} VmaAllocatorCreateInfo;

+

+/// Creates Allocator 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 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;

+

+/** \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.

+

+This function must be used if you make allocations with

+#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT and

+#VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flags to inform the allocator

+when a new frame begins. Allocations queried using vmaGetAllocationInfo() cannot

+become lost in the current frame.

+*/

+VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(

+    VmaAllocator VMA_NOT_NULL allocator,

+    uint32_t frameIndex);

+

+/** \brief Calculated statistics of memory usage in entire allocator.

+*/

+typedef struct VmaStatInfo

+{

+    /// Number of `VkDeviceMemory` Vulkan memory blocks allocated.

+    uint32_t blockCount;

+    /// Number of #VmaAllocation allocation objects allocated.

+    uint32_t allocationCount;

+    /// Number of free ranges of memory between allocations.

+    uint32_t unusedRangeCount;

+    /// Total number of bytes occupied by all allocations.

+    VkDeviceSize usedBytes;

+    /// Total number of bytes occupied by unused ranges.

+    VkDeviceSize unusedBytes;

+    VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;

+    VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;

+} VmaStatInfo;

+

+/// General statistics from current state of Allocator.

+typedef struct VmaStats

+{

+    VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];

+    VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];

+    VmaStatInfo total;

+} VmaStats;

+

+/** \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. For faster but more brief statistics

+suitable to be called every frame or every allocation, use vmaGetBudget().

+

+Note that when using allocator from multiple threads, returned information may immediately

+become outdated.

+*/

+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaStats* VMA_NOT_NULL pStats);

+

+/** \brief Statistics of current memory usage and available budget, in bytes, for specific memory heap.

+*/

+typedef struct VmaBudget

+{

+    /** \brief Sum size of all `VkDeviceMemory` blocks allocated from particular heap, in bytes.

+    */

+    VkDeviceSize blockBytes;

+

+    /** \brief Sum size of all allocations created in particular heap, in bytes.

+

+    Usually less or equal than `blockBytes`.

+    Difference `blockBytes - allocationBytes` is the amount of memory allocated but unused -

+    available for new allocations or wasted due to fragmentation.

+

+    It might be greater than `blockBytes` if there are some allocations in lost state, as they account

+    to this value as well.

+    */

+    VkDeviceSize allocationBytes;

+

+    /** \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 `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, like other programs also consuming system resources.

+    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;

+

+/** \brief Retrieves information about current memory budget for all memory heaps.

+

+\param[out] pBudget 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 vmaCalculateStats().

+

+Note that when using allocator from multiple threads, returned information may immediately

+become outdated.

+*/

+VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaBudget* VMA_NOT_NULL pBudget);

+

+#ifndef VMA_STATS_STRING_ENABLED

+#define VMA_STATS_STRING_ENABLED 1

+#endif

+

+#if VMA_STATS_STRING_ENABLED

+

+/// Builds and returns statistics as string in JSON format.

+/** @param[out] ppStatsString Must be freed using vmaFreeStatsString() function.

+*/

+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 // #if VMA_STATS_STRING_ENABLED

+

+/** \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)

+

+typedef enum VmaMemoryUsage

+{

+    /** No intended memory usage specified.

+    Use other members of VmaAllocationCreateInfo to specify your requirements.

+    */

+    VMA_MEMORY_USAGE_UNKNOWN = 0,

+    /** Memory will be used on device only, so fast access from the device is preferred.

+    It usually means device-local GPU (video) memory.

+    No need to be mappable on host.

+    It is roughly equivalent of `D3D12_HEAP_TYPE_DEFAULT`.

+

+    Usage:

+

+    - Resources written and read by device, e.g. images used as attachments.

+    - Resources transferred from host once (immutable) or infrequently and read by

+      device multiple times, e.g. textures to be sampled, vertex buffers, uniform

+      (constant) buffers, and majority of other types of resources used on GPU.

+

+    Allocation may still end up in `HOST_VISIBLE` memory on some implementations.

+    In such case, you are free to map it.

+    You can use #VMA_ALLOCATION_CREATE_MAPPED_BIT with this usage type.

+    */

+    VMA_MEMORY_USAGE_GPU_ONLY = 1,

+    /** Memory will be mappable on host.

+    It usually means CPU (system) memory.

+    Guarantees to be `HOST_VISIBLE` and `HOST_COHERENT`.

+    CPU access is typically uncached. Writes may be write-combined.

+    Resources created in this pool may still be accessible to the device, but access to them can be slow.

+    It is roughly equivalent of `D3D12_HEAP_TYPE_UPLOAD`.

+

+    Usage: Staging copy of resources used as transfer source.

+    */

+    VMA_MEMORY_USAGE_CPU_ONLY = 2,

+    /**

+    Memory that is both mappable on host (guarantees to be `HOST_VISIBLE`) and preferably fast to access by GPU.

+    CPU access is typically uncached. Writes may be write-combined.

+

+    Usage: Resources written frequently by host (dynamic), read by device. E.g. textures (with LINEAR layout), vertex buffers, uniform buffers updated every frame or every draw call.

+    */

+    VMA_MEMORY_USAGE_CPU_TO_GPU = 3,

+    /** Memory mappable on host (guarantees to be `HOST_VISIBLE`) and cached.

+    It is roughly equivalent of `D3D12_HEAP_TYPE_READBACK`.

+

+    Usage:

+

+    - Resources written by device, read by host - results of some computations, e.g. screen capture, average scene luminance for HDR tone mapping.

+    - Any resources read or accessed randomly on host, e.g. CPU-side copy of vertex buffer used as source of transfer, but also used for collision detection.

+    */

+    VMA_MEMORY_USAGE_GPU_TO_CPU = 4,

+    /** CPU memory - memory that is preferably not `DEVICE_LOCAL`, but also not guaranteed to be `HOST_VISIBLE`.

+

+    Usage: Staging copy of resources moved from GPU memory to CPU memory as part

+    of custom paging/residency mechanism, to be moved back to GPU memory when needed.

+    */

+    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,

+

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

+

+    You should not use this flag if VmaAllocationCreateInfo::pool is not null.

+    */

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

+

+    If VmaAllocationCreateInfo::pool is not null, this flag is implied and ignored. */

+    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).

+

+    You should not use this flag together with #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT.

+    */

+    VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,

+    /** Allocation created with this flag can become lost as a result of another

+    allocation with #VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flag, so you

+    must check it before use.

+

+    To check if allocation is not lost, call vmaGetAllocationInfo() and check if

+    VmaAllocationInfo::deviceMemory is not `VK_NULL_HANDLE`.

+

+    For details about supporting lost allocations, see Lost Allocations

+    chapter of User Guide on Main Page.

+

+    You should not use this flag together with #VMA_ALLOCATION_CREATE_MAPPED_BIT.

+    */

+    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,

+    /** While creating allocation using this flag, other allocations that were

+    created with flag #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT can become lost.

+

+    For details about supporting lost allocations, see Lost Allocations

+    chapter of User Guide on Main Page.

+    */

+    VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,

+    /** 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 `pUserData`. 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.

+    */

+    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,

+

+    /** Allocation strategy that chooses smallest possible free range for the

+    allocation.

+    */

+    VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT  = 0x00010000,

+    /** Allocation strategy that chooses biggest possible free range for the

+    allocation.

+    */

+    VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT = 0x00020000,

+    /** Allocation strategy that chooses first suitable free range for the

+    allocation.

+

+    "First" doesn't necessarily means the one with smallest offset in memory,

+    but rather the one that is easiest and fastest to find.

+    */

+    VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = 0x00040000,

+

+    /** Allocation strategy that tries to minimize memory usage.

+    */

+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,

+    /** Allocation strategy that tries to minimize allocation time.

+    */

+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,

+    /** Allocation strategy that tries to minimize memory fragmentation.

+    */

+    VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT = VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT,

+

+    /** A bit mask to extract only `STRATEGY` bits from entire set of flags.

+    */

+    VMA_ALLOCATION_CREATE_STRATEGY_MASK =

+        VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT |

+        VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT |

+        VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,

+

+    VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

+} VmaAllocationCreateFlagBits;

+typedef VkFlags VmaAllocationCreateFlags;

+

+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;

+} VmaAllocationCreateInfo;

+

+/**

+\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.

+It is just a convenience function, equivalent to calling:

+

+- `vkCreateBuffer`

+- `vkGetBufferMemoryRequirements`

+- `vmaFindMemoryTypeIndex`

+- `vkDestroyBuffer`

+*/

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

+It is just a convenience function, equivalent to calling:

+

+- `vkCreateImage`

+- `vkGetImageMemoryRequirements`

+- `vmaFindMemoryTypeIndex`

+- `vkDestroyImage`

+*/

+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);

+

+/// 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.

+

+    When using this flag, you must specify VmaPoolCreateInfo::maxBlockCount == 1 (or 0 for default).

+

+    For more details, see [Linear allocation algorithm](@ref linear_algorithm).

+    */

+    VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,

+

+    /** \brief Enables alternative, buddy allocation algorithm in this pool.

+

+    It operates on a tree of blocks, each having size that is a power of two and

+    a half of its parent's size. Comparing to default algorithm, this one provides

+    faster allocation and deallocation and decreased external fragmentation,

+    at the expense of more memory wasted (internal fragmentation).

+

+    For more details, see [Buddy allocation algorithm](@ref buddy_algorithm).

+    */

+    VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT = 0x00000008,

+

+    /** 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_BUDDY_ALGORITHM_BIT,

+

+    VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

+} VmaPoolCreateFlagBits;

+typedef VkFlags VmaPoolCreateFlags;

+

+/** \brief 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.

+    */

+    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 Maximum number of additional frames that are in use at the same time as current frame.

+

+    This value is used only when you make allocations with

+    #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocation cannot become

+    lost if allocation.lastUseFrameIndex >= allocator.currentFrameIndex - frameInUseCount.

+

+    For example, if you double-buffer your command buffers, so resources used for

+    rendering in previous frame may still be in use by the GPU at the moment you

+    allocate resources needed for the current frame, set this value to 1.

+

+    If you want to allow any allocations other than used in the current frame to

+    become lost, set this value to 0.

+    */

+    uint32_t frameInUseCount;

+} VmaPoolCreateInfo;

+

+/** \brief Describes parameter of existing #VmaPool.

+*/

+typedef struct VmaPoolStats {

+    /** \brief Total amount of `VkDeviceMemory` allocated from Vulkan for this pool, in bytes.

+    */

+    VkDeviceSize size;

+    /** \brief Total number of bytes in the pool not used by any #VmaAllocation.

+    */

+    VkDeviceSize unusedSize;

+    /** \brief Number of #VmaAllocation objects created from this pool that were not destroyed or lost.

+    */

+    size_t allocationCount;

+    /** \brief Number of continuous memory ranges in the pool not used by any #VmaAllocation.

+    */

+    size_t unusedRangeCount;

+    /** \brief Size of the largest continuous free memory region available for new allocation.

+

+    Making a new allocation of that size is not guaranteed to succeed because of

+    possible additional margin required to respect alignment and buffer/image

+    granularity.

+    */

+    VkDeviceSize unusedRangeSizeMax;

+    /** \brief Number of `VkDeviceMemory` blocks allocated for this pool.

+    */

+    size_t blockCount;

+} VmaPoolStats;

+

+/** \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);

+

+/** \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 vmaGetPoolStats(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaPool VMA_NOT_NULL pool,

+    VmaPoolStats* VMA_NOT_NULL pPoolStats);

+

+/** \brief Marks all allocations in given pool as lost if they are not used in current frame or VmaPoolCreateInfo::frameInUseCount back from now.

+

+@param allocator Allocator object.

+@param pool Pool.

+@param[out] pLostAllocationCount Number of allocations marked as lost. Optional - pass null if you don't need this information.

+*/

+VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaPool VMA_NOT_NULL pool,

+    size_t* VMA_NULLABLE pLostAllocationCount);

+

+/** \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_VALIDATION_FAILED_EXT` - 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);

+

+/** \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.

+

+Some kinds allocations can be in lost state.

+For more information, see [Lost allocations](@ref lost_allocations).

+*/

+VK_DEFINE_HANDLE(VmaAllocation)

+

+/** \brief 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 call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.

+

+    If the allocation is lost, it is equal to `VK_NULL_HANDLE`.

+    */

+    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 call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.

+    */

+    VkDeviceSize offset;

+    /** \brief Size of this allocation, in bytes.

+

+    It never changes, unless allocation is lost.

+

+    \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 call to vmaDefragment() if this allocation is passed to the function.

+    */

+    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;

+} VmaAllocationInfo;

+

+/** \brief General purpose memory allocation.

+

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

+@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);

+

+/**

+@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().

+*/

+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);

+

+/// Function similar to vmaAllocateMemoryForBuffer().

+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 Deprecated.

+

+\deprecated

+In version 2.2.0 it used to try to change allocation's size without moving or reallocating it.

+In current version it returns `VK_SUCCESS` only if `newSize` equals current allocation's size.

+Otherwise returns `VK_ERROR_OUT_OF_POOL_MEMORY`, indicating that allocation's size could not be changed.

+*/

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaAllocation VMA_NOT_NULL allocation,

+    VkDeviceSize newSize);

+

+/** \brief Returns current information about specified allocation and atomically marks it as used in current frame.

+

+Current paramteres of given allocation are returned in `pAllocationInfo`.

+

+This function also atomically "touches" allocation - marks it as used in current frame,

+just like vmaTouchAllocation().

+If the allocation is in lost state, `pAllocationInfo->deviceMemory == VK_NULL_HANDLE`.

+

+Although this function uses atomics and doesn't lock any mutex, so it should be quite efficient,

+you can 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 or allocation becoming lost).

+- If you just want to check if allocation is not lost, vmaTouchAllocation() will work faster.

+*/

+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaAllocation VMA_NOT_NULL allocation,

+    VmaAllocationInfo* VMA_NOT_NULL pAllocationInfo);

+

+/** \brief Returns `VK_TRUE` if allocation is not lost and atomically marks it as used in current frame.

+

+If the allocation has been created with #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,

+this function returns `VK_TRUE` if it's not in lost state, so it can still be used.

+It then also atomically "touches" the allocation - marks it as used in current frame,

+so that you can be sure it won't become lost in current frame or next `frameInUseCount` frames.

+

+If the allocation is in lost state, the function returns `VK_FALSE`.

+Memory of such allocation, as well as buffer or image bound to it, should not be used.

+Lost allocation and the buffer/image still need to be destroyed.

+

+If the allocation has been created without #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,

+this function always returns `VK_TRUE`.

+*/

+VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaAllocation VMA_NOT_NULL allocation);

+

+/** \brief Sets pUserData in given allocation to new value.

+

+If the allocation was created with VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT,

+pUserData 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 `pUserData`. String

+passed as pUserData 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

+pUserData is freed from memory.

+

+If the flag was not used, the value of pointer `pUserData` is just 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 Creates new allocation that is in lost state from the beginning.

+

+It can be useful if you need a dummy, non-null allocation.

+

+You still need to destroy created object using vmaFreeMemory().

+

+Returned allocation is not tied to any specific memory pool or memory type and

+not bound to any image or buffer. It has size = 0. It cannot be turned into

+a real, non-empty allocation.

+*/

+VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaAllocation VMA_NULLABLE * VMA_NOT_NULL pAllocation);

+

+/** \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.

+If the allocation is part of bigger `VkDeviceMemory` block, the pointer is

+correctly offseted to the beginning of region assigned to this particular

+allocation.

+

+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 always fails when called for allocation that was created with

+#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocations cannot be

+mapped.

+

+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 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_VALIDATION_FAILED_EXT` - 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);

+

+/** \struct VmaDefragmentationContext

+\brief Represents Opaque object that represents started defragmentation process.

+

+Fill structure #VmaDefragmentationInfo2 and call function vmaDefragmentationBegin() to create it.

+Call function vmaDefragmentationEnd() to destroy it.

+*/

+VK_DEFINE_HANDLE(VmaDefragmentationContext)

+

+/// Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.

+typedef enum VmaDefragmentationFlagBits {

+    VMA_DEFRAGMENTATION_FLAG_INCREMENTAL = 0x1,

+    VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

+} VmaDefragmentationFlagBits;

+typedef VkFlags VmaDefragmentationFlags;

+

+/** \brief Parameters for defragmentation.

+

+To be used with function vmaDefragmentationBegin().

+*/

+typedef struct VmaDefragmentationInfo2 {

+    /** \brief Reserved for future use. Should be 0.

+    */

+    VmaDefragmentationFlags flags;

+    /** \brief Number of allocations in `pAllocations` array.

+    */

+    uint32_t allocationCount;

+    /** \brief Pointer to array of allocations that can be defragmented.

+

+    The array should have `allocationCount` elements.

+    The array should not contain nulls.

+    Elements in the array should be unique - same allocation cannot occur twice.

+    It is safe to pass allocations that are in the lost state - they are ignored.

+    All allocations not present in this array are considered non-moveable during this defragmentation.

+    */

+    const VmaAllocation VMA_NOT_NULL * VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations;

+    /** \brief Optional, output. Pointer to array that will be filled with information whether the allocation at certain index has been changed during defragmentation.

+

+    The array should have `allocationCount` elements.

+    You can pass null if you are not interested in this information.

+    */

+    VkBool32* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocationsChanged;

+    /** \brief Numer of pools in `pPools` array.

+    */

+    uint32_t poolCount;

+    /** \brief Either null or pointer to array of pools to be defragmented.

+

+    All the allocations in the specified pools can be moved during defragmentation

+    and there is no way to check if they were really moved as in `pAllocationsChanged`,

+    so you must query all the allocations in all these pools for new `VkDeviceMemory`

+    and offset using vmaGetAllocationInfo() if you might need to recreate buffers

+    and images bound to them.

+

+    The array should have `poolCount` elements.

+    The array should not contain nulls.

+    Elements in the array should be unique - same pool cannot occur twice.

+

+    Using this array is equivalent to specifying all allocations from the pools in `pAllocations`.

+    It might be more efficient.

+    */

+    const VmaPool VMA_NOT_NULL * VMA_NULLABLE VMA_LEN_IF_NOT_NULL(poolCount) pPools;

+    /** \brief Maximum total numbers of bytes that can be copied while moving allocations to different places using transfers on CPU side, like `memcpy()`, `memmove()`.

+

+    `VK_WHOLE_SIZE` means no limit.

+    */

+    VkDeviceSize maxCpuBytesToMove;

+    /** \brief Maximum number of allocations that can be moved to a different place using transfers on CPU side, like `memcpy()`, `memmove()`.

+

+    `UINT32_MAX` means no limit.

+    */

+    uint32_t maxCpuAllocationsToMove;

+    /** \brief Maximum total numbers of bytes that can be copied while moving allocations to different places using transfers on GPU side, posted to `commandBuffer`.

+

+    `VK_WHOLE_SIZE` means no limit.

+    */

+    VkDeviceSize maxGpuBytesToMove;

+    /** \brief Maximum number of allocations that can be moved to a different place using transfers on GPU side, posted to `commandBuffer`.

+

+    `UINT32_MAX` means no limit.

+    */

+    uint32_t maxGpuAllocationsToMove;

+    /** \brief Optional. Command buffer where GPU copy commands will be posted.

+

+    If not null, it must be a valid command buffer handle that supports Transfer queue type.

+    It must be in the recording state and outside of a render pass instance.

+    You need to submit it and make sure it finished execution before calling vmaDefragmentationEnd().

+

+    Passing null means that only CPU defragmentation will be performed.

+    */

+    VkCommandBuffer VMA_NULLABLE commandBuffer;

+} VmaDefragmentationInfo2;

+

+typedef struct VmaDefragmentationPassMoveInfo {

+    VmaAllocation VMA_NOT_NULL allocation;

+    VkDeviceMemory VMA_NOT_NULL_NON_DISPATCHABLE memory;

+    VkDeviceSize offset;

+} VmaDefragmentationPassMoveInfo;

+

+/** \brief Parameters for incremental defragmentation steps.

+

+To be used with function vmaBeginDefragmentationPass().

+*/

+typedef struct VmaDefragmentationPassInfo {

+    uint32_t moveCount;

+    VmaDefragmentationPassMoveInfo* VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(moveCount) pMoves;

+} VmaDefragmentationPassInfo;

+

+/** \brief Deprecated. Optional configuration parameters to be passed to function vmaDefragment().

+

+\deprecated This is a part of the old interface. It is recommended to use structure #VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.

+*/

+typedef struct VmaDefragmentationInfo {

+    /** \brief Maximum total numbers of bytes that can be copied while moving allocations to different places.

+

+    Default is `VK_WHOLE_SIZE`, which means no limit.

+    */

+    VkDeviceSize maxBytesToMove;

+    /** \brief Maximum number of allocations that can be moved to different place.

+

+    Default is `UINT32_MAX`, which means no limit.

+    */

+    uint32_t maxAllocationsToMove;

+} VmaDefragmentationInfo;

+

+/** \brief Statistics returned by function vmaDefragment(). */

+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;

+

+/** \brief Begins defragmentation process.

+

+@param allocator Allocator object.

+@param pInfo Structure filled with parameters of defragmentation.

+@param[out] pStats Optional. Statistics of defragmentation. You can pass null if you are not interested in this information.

+@param[out] pContext Context object that must be passed to vmaDefragmentationEnd() to finish defragmentation.

+@return `VK_SUCCESS` and `*pContext == null` if defragmentation finished within this function call. `VK_NOT_READY` and `*pContext != null` if defragmentation has been started and you need to call vmaDefragmentationEnd() to finish it. Negative value in case of error.

+

+Use this function instead of old, deprecated vmaDefragment().

+

+Warning! Between the call to vmaDefragmentationBegin() and vmaDefragmentationEnd():

+

+- You should not use any of allocations passed as `pInfo->pAllocations` or

+  any allocations that belong to pools passed as `pInfo->pPools`,

+  including calling vmaGetAllocationInfo(), vmaTouchAllocation(), or access

+  their data.

+- Some mutexes protecting internal data structures may be locked, so trying to

+  make or free any allocations, bind buffers or images, map memory, or launch

+  another simultaneous defragmentation in between may cause stall (when done on

+  another thread) or deadlock (when done on the same thread), unless you are

+  100% sure that defragmented allocations are in different pools.

+- Information returned via `pStats` and `pInfo->pAllocationsChanged` are undefined.

+  They become valid after call to vmaDefragmentationEnd().

+- If `pInfo->commandBuffer` is not null, you must submit that command buffer

+  and make sure it finished execution before calling vmaDefragmentationEnd().

+

+For more information and important limitations regarding defragmentation, see documentation chapter:

+[Defragmentation](@ref defragmentation).

+*/

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(

+    VmaAllocator VMA_NOT_NULL allocator,

+    const VmaDefragmentationInfo2* VMA_NOT_NULL pInfo,

+    VmaDefragmentationStats* VMA_NULLABLE pStats,

+    VmaDefragmentationContext VMA_NULLABLE * VMA_NOT_NULL pContext);

+

+/** \brief Ends defragmentation process.

+

+Use this function to finish defragmentation started by vmaDefragmentationBegin().

+It is safe to pass `context == null`. The function then does nothing.

+*/

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaDefragmentationContext VMA_NULLABLE context);

+

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaDefragmentationContext VMA_NULLABLE context,

+    VmaDefragmentationPassInfo* VMA_NOT_NULL pInfo

+);

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(

+    VmaAllocator VMA_NOT_NULL allocator,

+    VmaDefragmentationContext VMA_NULLABLE context

+);

+

+/** \brief Deprecated. Compacts memory by moving allocations.

+

+@param pAllocations Array of allocations that can be moved during this compation.

+@param allocationCount Number of elements in pAllocations and pAllocationsChanged arrays.

+@param[out] pAllocationsChanged Array of boolean values that will indicate whether matching allocation in pAllocations array has been moved. This parameter is optional. Pass null if you don't need this information.

+@param pDefragmentationInfo Configuration parameters. Optional - pass null to use default values.

+@param[out] pDefragmentationStats Statistics returned by the function. Optional - pass null if you don't need this information.

+@return `VK_SUCCESS` if completed, negative error code in case of error.

+

+\deprecated This is a part of the old interface. It is recommended to use structure #VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.

+

+This function works by moving allocations to different places (different

+`VkDeviceMemory` objects and/or different offsets) in order to optimize memory

+usage. Only allocations that are in `pAllocations` array can be moved. All other

+allocations are considered nonmovable in this call. Basic rules:

+

+- Only allocations made in memory types that have

+  `VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` and `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT`

+  flags can be compacted. You may pass other allocations but it makes no sense -

+  these will never be moved.

+- Custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT or

+  #VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT flag are not defragmented. Allocations

+  passed to this function that come from such pools are ignored.

+- Allocations created with #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT or

+  created as dedicated allocations for any other reason are also ignored.

+- Both allocations made with or without #VMA_ALLOCATION_CREATE_MAPPED_BIT

+  flag can be compacted. If not persistently mapped, memory will be mapped

+  temporarily inside this function if needed.

+- You must not pass same #VmaAllocation object multiple times in `pAllocations` array.

+

+The function also frees empty `VkDeviceMemory` blocks.

+

+Warning: This function may be time-consuming, so you shouldn't call it too often

+(like after every resource creation/destruction).

+You can call it on special occasions (like when reloading a game level or

+when you just destroyed a lot of objects). Calling it every frame may be OK, but

+you should measure that on your platform.

+

+For more information, see [Defragmentation](@ref defragmentation) chapter.

+*/

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(

+    VmaAllocator VMA_NOT_NULL allocator,

+    const VmaAllocation VMA_NOT_NULL * VMA_NOT_NULL VMA_LEN_IF_NOT_NULL(allocationCount) pAllocations,

+    size_t allocationCount,

+    VkBool32* VMA_NULLABLE VMA_LEN_IF_NOT_NULL(allocationCount) pAllocationsChanged,

+    const VmaDefragmentationInfo* VMA_NULLABLE pDefragmentationInfo,

+    VmaDefragmentationStats* VMA_NULLABLE pDefragmentationStats);

+

+/** \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 allocationLocalOffset Additional offset to be added while binding, relative to the beginnig of the `allocation`. Normally it should be 0.

+@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 allocationLocalOffset Additional offset to be added while binding, relative to the beginnig of the `allocation`. Normally it should be 0.

+@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);

+

+/**

+@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 (VmaAllocationCreateInfo::pool is null

+and #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 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);

+

+/** \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);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif // AMD_VULKAN_MEMORY_ALLOCATOR_H

+

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

+

+#if VMA_RECORDING_ENABLED

+    #include <chrono>

+    #if defined(_WIN32)

+        #include <windows.h>

+    #else

+        #include <sstream>

+        #include <thread>

+    #endif

+#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.

+*/

+

+/*

+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(m_hDevice, vkAllocateMemory);

+*/

+#if !defined(VMA_DYNAMIC_VULKAN_FUNCTIONS)

+    #define VMA_DYNAMIC_VULKAN_FUNCTIONS 1

+    #if defined(VK_NO_PROTOTYPES)

+        extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;

+        extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;

+    #endif

+#endif

+

+// Define this macro to 1 to make the library use STL containers instead of its own implementation.

+//#define VMA_USE_STL_CONTAINERS 1

+

+/* Set this macro to 1 to make the library including and using STL containers:

+std::pair, std::vector, std::list, std::unordered_map.

+

+Set it to 0 or undefined to make the library using its own implementation of

+the containers.

+*/

+#if VMA_USE_STL_CONTAINERS

+   #define VMA_USE_STL_VECTOR 1

+   #define VMA_USE_STL_UNORDERED_MAP 1

+   #define VMA_USE_STL_LIST 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's always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.

+    // See: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/

+    #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

+

+/*

+THESE INCLUDES ARE NOT ENABLED BY DEFAULT.

+Library has its own container implementation.

+*/

+#if VMA_USE_STL_VECTOR

+   #include <vector>

+#endif

+

+#if VMA_USE_STL_UNORDERED_MAP

+   #include <unordered_map>

+#endif

+

+#if VMA_USE_STL_LIST

+   #include <list>

+#endif

+

+/*

+Following headers are used in this CONFIGURATION section only, so feel free to

+remove them if not needed.

+*/

+#include <cassert> // for assert

+#include <algorithm> // for min, max

+#include <mutex>

+

+#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)

+{

+#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's 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* 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_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* outStr, size_t strLen, uint32_t num)

+    {

+        snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));

+    }

+    static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)

+    {

+        snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));

+    }

+    static inline void VmaPtrToStr(char* 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_DEBUG_ALIGNMENT

+    /**

+    Minimum alignment of all allocations, in bytes.

+    Set to more than 1 for debugging purposes only. Must be power of two.

+    */

+    #define VMA_DEBUG_ALIGNMENT (1)

+#endif

+

+#ifndef VMA_DEBUG_MARGIN

+    /**

+    Minimum margin before and 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 before and 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_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

+

+#ifndef VMA_CLASS_NO_COPY

+    #define VMA_CLASS_NO_COPY(className) \

+        private: \

+            className(const className&) = delete; \

+            className& operator=(const className&) = delete;

+#endif

+

+static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;

+

+// Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.

+static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;

+

+static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED   = 0xDC;

+static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;

+

+/*******************************************************************************

+END OF CONFIGURATION

+*/

+

+// # 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 VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;

+

+static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {

+    VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };

+

+// Returns number of bits set to 1 in (v).

+static inline uint32_t VmaCountBitsSet(uint32_t v)

+{

+    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;

+}

+

+/*

+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;

+}

+

+// 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';

+}

+

+#if VMA_STATS_STRING_ENABLED

+

+static const char* VmaAlgorithmToStr(uint32_t algorithm)

+{

+    switch(algorithm)

+    {

+    case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:

+        return "Linear";

+    case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:

+        return "Buddy";

+    case 0:

+        return "Default";

+    default:

+        VMA_ASSERT(0);

+        return "";

+    }

+}

+

+#endif // #if VMA_STATS_STRING_ENABLED

+

+#ifndef VMA_SORT

+

+template<typename Iterator, typename Compare>

+Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)

+{

+    Iterator centerValue = end; --centerValue;

+    Iterator insertIndex = beg;

+    for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)

+    {

+        if(cmp(*memTypeIndex, *centerValue))

+        {

+            if(insertIndex != memTypeIndex)

+            {

+                VMA_SWAP(*memTypeIndex, *insertIndex);

+            }

+            ++insertIndex;

+        }

+    }

+    if(insertIndex != centerValue)

+    {

+        VMA_SWAP(*insertIndex, *centerValue);

+    }

+    return insertIndex;

+}

+

+template<typename Iterator, typename Compare>

+void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)

+{

+    if(beg < end)

+    {

+        Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);

+        VmaQuickSort<Iterator, Compare>(beg, it, cmp);

+        VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);

+    }

+}

+

+#define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)

+

+#endif // #ifndef VMA_SORT

+

+/*

+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;

+}

+

+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

+};

+

+/*

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

+}

+

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

+

+// Minimum size of a free suballocation to register it in the free suballocation collection.

+static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;

+

+/*

+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;

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// 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;

+    }

+    else

+    {

+        return VMA_NULL;

+    }

+}

+

+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);

+    }

+}

+

+// STL-compatible allocator.

+template<typename T>

+class VmaStlAllocator

+{

+public:

+    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) { }

+

+    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;

+    }

+

+    VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;

+};

+

+#if VMA_USE_STL_VECTOR

+

+#define VmaVector std::vector

+

+template<typename T, typename allocatorT>

+static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)

+{

+    vec.insert(vec.begin() + index, item);

+}

+

+template<typename T, typename allocatorT>

+static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)

+{

+    vec.erase(vec.begin() + index);

+}

+

+#else // #if VMA_USE_STL_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;

+

+    VmaVector(const AllocatorT& allocator) :

+        m_Allocator(allocator),

+        m_pArray(VMA_NULL),

+        m_Count(0),

+        m_Capacity(0)

+    {

+    }

+

+    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)

+    {

+    }

+

+    // 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) :

+        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));

+        }

+    }

+

+    ~VmaVector()

+    {

+        VmaFree(m_Allocator.m_pCallbacks, m_pArray);

+    }

+

+    VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)

+    {

+        if(&rhs != this)

+        {

+            resize(rhs.m_Count);

+            if(m_Count != 0)

+            {

+                memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));

+            }

+        }

+        return *this;

+    }

+

+    bool empty() const { return m_Count == 0; }

+    size_t size() const { return m_Count; }

+    T* data() { return m_pArray; }

+    const T* data() const { return m_pArray; }

+

+    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];

+    }

+

+    T& front()

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        return m_pArray[0];

+    }

+    const T& front() const

+    {

+        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& back() const

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        return m_pArray[m_Count - 1];

+    }

+

+    void reserve(size_t newCapacity, bool freeMemory = false)

+    {

+        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;

+        }

+    }

+

+    void resize(size_t newCount, bool freeMemory = false)

+    {

+        size_t newCapacity = m_Capacity;

+        if(newCount > m_Capacity)

+        {

+            newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));

+        }

+        else if(freeMemory)

+        {

+            newCapacity = newCount;

+        }

+

+        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;

+    }

+

+    void clear(bool freeMemory = false)

+    {

+        resize(0, freeMemory);

+    }

+

+    void 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;

+    }

+

+    void 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);

+    }

+

+    void push_back(const T& src)

+    {

+        const size_t newIndex = size();

+        resize(newIndex + 1);

+        m_pArray[newIndex] = src;

+    }

+

+    void pop_back()

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        resize(size() - 1);

+    }

+

+    void push_front(const T& src)

+    {

+        insert(0, src);

+    }

+

+    void pop_front()

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        remove(0);

+    }

+

+    typedef T* iterator;

+

+    iterator begin() { return m_pArray; }

+    iterator end() { return m_pArray + m_Count; }

+

+private:

+    AllocatorT m_Allocator;

+    T* m_pArray;

+    size_t m_Count;

+    size_t m_Capacity;

+};

+

+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 // #if VMA_USE_STL_VECTOR

+

+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;

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaSmallVector

+

+/*

+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;

+

+    VmaSmallVector(const AllocatorT& allocator) :

+        m_Count(0),

+        m_DynamicArray(allocator)

+    {

+    }

+    VmaSmallVector(size_t count, const AllocatorT& allocator) :

+        m_Count(count),

+        m_DynamicArray(count > N ? count : 0, allocator)

+    {

+    }

+    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>

+    VmaSmallVector(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>& src) = delete;

+    template<typename SrcT, typename SrcAllocatorT, size_t SrcN>

+    VmaSmallVector<T, AllocatorT, N>& operator=(const VmaSmallVector<SrcT, SrcAllocatorT, SrcN>& rhs) = delete;

+

+    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; }

+    const T* data() const { return m_Count > N ? m_DynamicArray.data() : m_StaticArray; }

+

+    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];

+    }

+

+    T& front()

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        return data()[0];

+    }

+    const T& front() const

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        return data()[0];

+    }

+    T& back()

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        return data()[m_Count - 1];

+    }

+    const T& back() const

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        return data()[m_Count - 1];

+    }

+

+    void resize(size_t newCount, bool freeMemory = false)

+    {

+        if(newCount > N && m_Count > N)

+        {

+            // Any direction, staying in m_DynamicArray

+            m_DynamicArray.resize(newCount, freeMemory);

+        }

+        else if(newCount > N && m_Count <= N)

+        {

+            // Growing, moving from m_StaticArray to m_DynamicArray

+            m_DynamicArray.resize(newCount, freeMemory);

+            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, freeMemory);

+        }

+        else

+        {

+            // Any direction, staying in m_StaticArray - nothing to do here

+        }

+        m_Count = newCount;

+    }

+

+    void clear(bool freeMemory = false)

+    {

+        m_DynamicArray.clear(freeMemory);

+        m_Count = 0;

+    }

+

+    void 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;

+    }

+

+    void 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);

+    }

+

+    void push_back(const T& src)

+    {

+        const size_t newIndex = size();

+        resize(newIndex + 1);

+        data()[newIndex] = src;

+    }

+

+    void pop_back()

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        resize(size() - 1);

+    }

+

+    void push_front(const T& src)

+    {

+        insert(0, src);

+    }

+

+    void pop_front()

+    {

+        VMA_HEAVY_ASSERT(m_Count > 0);

+        remove(0);

+    }

+

+    typedef T* iterator;

+

+    iterator begin() { return data(); }

+    iterator end() { return data() + m_Count; }

+

+private:

+    size_t m_Count;

+    T m_StaticArray[N]; // Used when m_Size <= N

+    VmaVector<T, AllocatorT> m_DynamicArray; // Used when m_Size > N

+};

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaPoolAllocator

+

+/*

+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();

+};

+

+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();

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaRawList, VmaList

+

+#if VMA_USE_STL_LIST

+

+#define VmaList std::list

+

+#else // #if VMA_USE_STL_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);

+    ~VmaRawList();

+    void Clear();

+

+    size_t GetCount() const { return m_Count; }

+    bool IsEmpty() const { return m_Count == 0; }

+

+    ItemType* Front() { return m_pFront; }

+    const ItemType* Front() const { return m_pFront; }

+    ItemType* Back() { return m_pBack; }

+    const ItemType* Back() const { return m_pBack; }

+

+    ItemType* PushBack();

+    ItemType* PushFront();

+    ItemType* PushBack(const T& value);

+    ItemType* PushFront(const T& value);

+    void PopBack();

+    void PopFront();

+

+    // 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 Remove(ItemType* pItem);

+

+private:

+    const VkAllocationCallbacks* const m_pAllocationCallbacks;

+    VmaPoolAllocator<ItemType> m_ItemAllocator;

+    ItemType* m_pFront;

+    ItemType* m_pBack;

+    size_t m_Count;

+};

+

+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>

+VmaRawList<T>::~VmaRawList()

+{

+    // Intentionally not calling Clear, because that would be unnecessary

+    // computations to return all items to m_ItemAllocator as free.

+}

+

+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>

+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()

+{

+    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(const T& value)

+{

+    ItemType* const pNewItem = PushBack();

+    pNewItem->Value = value;

+    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>

+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>::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>::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;

+}

+

+template<typename T, typename AllocatorT>

+class VmaList

+{

+    VMA_CLASS_NO_COPY(VmaList)

+public:

+    class iterator

+    {

+    public:

+        iterator() :

+            m_pList(VMA_NULL),

+            m_pItem(VMA_NULL)

+        {

+        }

+

+        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;

+        }

+

+        iterator& operator++()

+        {

+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);

+            m_pItem = m_pItem->pNext;

+            return *this;

+        }

+        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;

+        }

+

+        iterator operator++(int)

+        {

+            iterator result = *this;

+            ++*this;

+            return result;

+        }

+        iterator operator--(int)

+        {

+            iterator result = *this;

+            --*this;

+            return result;

+        }

+

+        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;

+        }

+

+    private:

+        VmaRawList<T>* m_pList;

+        VmaListItem<T>* m_pItem;

+

+        iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :

+            m_pList(pList),

+            m_pItem(pItem)

+        {

+        }

+

+        friend class VmaList<T, AllocatorT>;

+    };

+

+    class const_iterator

+    {

+    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 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;

+        }

+

+        const_iterator& operator++()

+        {

+            VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);

+            m_pItem = m_pItem->pNext;

+            return *this;

+        }

+        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;

+        }

+

+        const_iterator operator++(int)

+        {

+            const_iterator result = *this;

+            ++*this;

+            return result;

+        }

+        const_iterator operator--(int)

+        {

+            const_iterator result = *this;

+            --*this;

+            return result;

+        }

+

+        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;

+        }

+

+    private:

+        const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :

+            m_pList(pList),

+            m_pItem(pItem)

+        {

+        }

+

+        const VmaRawList<T>* m_pList;

+        const VmaListItem<T>* m_pItem;

+

+        friend class VmaList<T, AllocatorT>;

+    };

+

+    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); }

+

+    void clear() { m_RawList.Clear(); }

+    void push_back(const T& value) { m_RawList.PushBack(value); }

+    void erase(iterator it) { m_RawList.Remove(it.m_pItem); }

+    iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }

+

+private:

+    VmaRawList<T> m_RawList;

+};

+

+#endif // #if VMA_USE_STL_LIST

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaMap

+

+// Unused in this version.

+#if 0

+

+#if VMA_USE_STL_UNORDERED_MAP

+

+#define VmaPair std::pair

+

+#define VMA_MAP_TYPE(KeyT, ValueT) \

+    std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >

+

+#else // #if VMA_USE_STL_UNORDERED_MAP

+

+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) { }

+};

+

+/* 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(); }

+

+    void insert(const PairType& pair);

+    iterator find(const KeyT& key);

+    void erase(iterator it);

+

+private:

+    VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;

+};

+

+#define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>

+

+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;

+    }

+};

+

+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 // #if VMA_USE_STL_UNORDERED_MAP

+

+#endif // #if 0

+

+////////////////////////////////////////////////////////////////////////////////

+

+class VmaDeviceMemoryBlock;

+

+enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };

+

+struct VmaAllocation_T

+{

+private:

+    static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;

+

+    enum FLAGS

+    {

+        FLAG_USER_DATA_STRING = 0x01,

+    };

+

+public:

+    enum ALLOCATION_TYPE

+    {

+        ALLOCATION_TYPE_NONE,

+        ALLOCATION_TYPE_BLOCK,

+        ALLOCATION_TYPE_DEDICATED,

+    };

+

+    /*

+    This struct is allocated using VmaPoolAllocator.

+    */

+

+    VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :

+        m_Alignment{1},

+        m_Size{0},

+        m_pUserData{VMA_NULL},

+        m_LastUseFrameIndex{currentFrameIndex},

+        m_MemoryTypeIndex{0},

+        m_Type{(uint8_t)ALLOCATION_TYPE_NONE},

+        m_SuballocationType{(uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN},

+        m_MapCount{0},

+        m_Flags{userDataString ? (uint8_t)FLAG_USER_DATA_STRING : (uint8_t)0}

+    {

+#if VMA_STATS_STRING_ENABLED

+        m_CreationFrameIndex = currentFrameIndex;

+        m_BufferImageUsage = 0;

+#endif

+    }

+

+    ~VmaAllocation_T()

+    {

+        VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");

+

+        // Check if owned string was freed.

+        VMA_ASSERT(m_pUserData == VMA_NULL);

+    }

+

+    void InitBlockAllocation(

+        VmaDeviceMemoryBlock* block,

+        VkDeviceSize offset,

+        VkDeviceSize alignment,

+        VkDeviceSize size,

+        uint32_t memoryTypeIndex,

+        VmaSuballocationType suballocationType,

+        bool mapped,

+        bool canBecomeLost)

+    {

+        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;

+        m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;

+        m_SuballocationType = (uint8_t)suballocationType;

+        m_BlockAllocation.m_Block = block;

+        m_BlockAllocation.m_Offset = offset;

+        m_BlockAllocation.m_CanBecomeLost = canBecomeLost;

+    }

+

+    void InitLost()

+    {

+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);

+        VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);

+        m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;

+        m_MemoryTypeIndex = 0;

+        m_BlockAllocation.m_Block = VMA_NULL;

+        m_BlockAllocation.m_Offset = 0;

+        m_BlockAllocation.m_CanBecomeLost = true;

+    }

+

+    void ChangeBlockAllocation(

+        VmaAllocator hAllocator,

+        VmaDeviceMemoryBlock* block,

+        VkDeviceSize offset);

+

+    void ChangeOffset(VkDeviceSize newOffset);

+

+    // pMappedData not null means allocation is created with MAPPED flag.

+    void InitDedicatedAllocation(

+        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;

+        m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;

+        m_DedicatedAllocation.m_hMemory = hMemory;

+        m_DedicatedAllocation.m_pMappedData = pMappedData;

+    }

+

+    ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }

+    VkDeviceSize GetAlignment() const { return m_Alignment; }

+    VkDeviceSize GetSize() const { return m_Size; }

+    bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }

+    void* GetUserData() const { return m_pUserData; }

+    void SetUserData(VmaAllocator hAllocator, void* pUserData);

+    VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }

+

+    VmaDeviceMemoryBlock* GetBlock() const

+    {

+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);

+        return m_BlockAllocation.m_Block;

+    }

+    VkDeviceSize GetOffset() const;

+    VkDeviceMemory GetMemory() const;

+    uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }

+    bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }

+    void* GetMappedData() const;

+    bool CanBecomeLost() const;

+

+    uint32_t GetLastUseFrameIndex() const

+    {

+        return m_LastUseFrameIndex.load();

+    }

+    bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)

+    {

+        return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);

+    }

+    /*

+    - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,

+      makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.

+    - Else, returns false.

+

+    If hAllocation is already lost, assert - you should not call it then.

+    If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.

+    */

+    bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);

+

+    void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)

+    {

+        VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);

+        outInfo.blockCount = 1;

+        outInfo.allocationCount = 1;

+        outInfo.unusedRangeCount = 0;

+        outInfo.usedBytes = m_Size;

+        outInfo.unusedBytes = 0;

+        outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;

+        outInfo.unusedRangeSizeMin = UINT64_MAX;

+        outInfo.unusedRangeSizeMax = 0;

+    }

+

+    void BlockAllocMap();

+    void BlockAllocUnmap();

+    VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);

+    void DedicatedAllocUnmap(VmaAllocator hAllocator);

+

+#if VMA_STATS_STRING_ENABLED

+    uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }

+    uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }

+

+    void InitBufferImageUsage(uint32_t bufferImageUsage)

+    {

+        VMA_ASSERT(m_BufferImageUsage == 0);

+        m_BufferImageUsage = bufferImageUsage;

+    }

+

+    void PrintParameters(class VmaJsonWriter& json) const;

+#endif

+

+private:

+    VkDeviceSize m_Alignment;

+    VkDeviceSize m_Size;

+    void* m_pUserData;

+    VMA_ATOMIC_UINT32 m_LastUseFrameIndex;

+    uint32_t m_MemoryTypeIndex;

+    uint8_t m_Type; // ALLOCATION_TYPE

+    uint8_t m_SuballocationType; // VmaSuballocationType

+    // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.

+    // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().

+    uint8_t m_MapCount;

+    uint8_t m_Flags; // enum FLAGS

+

+    // Allocation out of VmaDeviceMemoryBlock.

+    struct BlockAllocation

+    {

+        VmaDeviceMemoryBlock* m_Block;

+        VkDeviceSize m_Offset;

+        bool m_CanBecomeLost;

+    };

+

+    // Allocation for an object that has its own private VkDeviceMemory.

+    struct DedicatedAllocation

+    {

+        VkDeviceMemory m_hMemory;

+        void* m_pMappedData; // Not null means memory is mapped.

+    };

+

+    union

+    {

+        // Allocation out of VmaDeviceMemoryBlock.

+        BlockAllocation m_BlockAllocation;

+        // Allocation for an object that has its own private VkDeviceMemory.

+        DedicatedAllocation m_DedicatedAllocation;

+    };

+

+#if VMA_STATS_STRING_ENABLED

+    uint32_t m_CreationFrameIndex;

+    uint32_t m_BufferImageUsage; // 0 if unknown.

+#endif

+

+    void FreeUserDataString(VmaAllocator hAllocator);

+};

+

+/*

+Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as

+allocated memory block or free.

+*/

+struct VmaSuballocation

+{

+    VkDeviceSize offset;

+    VkDeviceSize size;

+    VmaAllocation hAllocation;

+    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;

+    }

+};

+

+typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;

+

+// Cost of one additional allocation lost, as equivalent in bytes.

+static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;

+

+enum class VmaAllocationRequestType

+{

+    Normal,

+    // Used by "Linear" algorithm.

+    UpperAddress,

+    EndOf1st,

+    EndOf2nd,

+};

+

+/*

+Parameters of planned allocation inside a VmaDeviceMemoryBlock.

+

+If canMakeOtherLost was false:

+- item points to a FREE suballocation.

+- itemsToMakeLostCount is 0.

+

+If canMakeOtherLost was true:

+- item points to first of sequence of suballocations, which are either FREE,

+  or point to VmaAllocations that can become lost.

+- itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for

+  the requested allocation to succeed.

+*/

+struct VmaAllocationRequest

+{

+    VkDeviceSize offset;

+    VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.

+    VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.

+    VmaSuballocationList::iterator item;

+    size_t itemsToMakeLostCount;

+    void* customData;

+    VmaAllocationRequestType type;

+

+    VkDeviceSize CalcCost() const

+    {

+        return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;

+    }

+};

+

+/*

+Data structure used for bookkeeping of allocations and unused ranges of memory

+in a single VkDeviceMemory block.

+*/

+class VmaBlockMetadata

+{

+public:

+    VmaBlockMetadata(VmaAllocator hAllocator);

+    virtual ~VmaBlockMetadata() { }

+    virtual void Init(VkDeviceSize size) { m_Size = size; }

+

+    // Validates all data structures inside this object. If not valid, returns false.

+    virtual bool Validate() const = 0;

+    VkDeviceSize GetSize() const { return m_Size; }

+    virtual size_t GetAllocationCount() const = 0;

+    virtual VkDeviceSize GetSumFreeSize() const = 0;

+    virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;

+    // Returns true if this block is empty - contains only single free suballocation.

+    virtual bool IsEmpty() const = 0;

+

+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;

+    // Shouldn't modify blockCount.

+    virtual void AddPoolStats(VmaPoolStats& 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(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VkDeviceSize bufferImageGranularity,

+        VkDeviceSize allocSize,

+        VkDeviceSize allocAlignment,

+        bool upperAddress,

+        VmaSuballocationType allocType,

+        bool canMakeOtherLost,

+        // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.

+        uint32_t strategy,

+        VmaAllocationRequest* pAllocationRequest) = 0;

+

+    virtual bool MakeRequestedAllocationsLost(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VmaAllocationRequest* pAllocationRequest) = 0;

+

+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 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,

+        VkDeviceSize allocSize,

+        VmaAllocation hAllocation) = 0;

+

+    // Frees suballocation assigned to given memory region.

+    virtual void Free(const VmaAllocation allocation) = 0;

+    virtual void FreeAtOffset(VkDeviceSize offset) = 0;

+

+protected:

+    const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }

+

+#if VMA_STATS_STRING_ENABLED

+    void PrintDetailedMap_Begin(class VmaJsonWriter& json,

+        VkDeviceSize unusedBytes,

+        size_t allocationCount,

+        size_t unusedRangeCount) const;

+    void PrintDetailedMap_Allocation(class VmaJsonWriter& json,

+        VkDeviceSize offset,

+        VmaAllocation hAllocation) 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;

+};

+

+#define VMA_VALIDATE(cond) do { if(!(cond)) { \

+        VMA_ASSERT(0 && "Validation failed: " #cond); \

+        return false; \

+    } } while(false)

+

+class VmaBlockMetadata_Generic : public VmaBlockMetadata

+{

+    VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)

+public:

+    VmaBlockMetadata_Generic(VmaAllocator hAllocator);

+    virtual ~VmaBlockMetadata_Generic();

+    virtual void Init(VkDeviceSize size);

+

+    virtual bool Validate() const;

+    virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }

+    virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }

+    virtual VkDeviceSize GetUnusedRangeSizeMax() const;

+    virtual bool IsEmpty() const;

+

+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;

+    virtual void AddPoolStats(VmaPoolStats& inoutStats) const;

+

+#if VMA_STATS_STRING_ENABLED

+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const;

+#endif

+

+    virtual bool CreateAllocationRequest(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VkDeviceSize bufferImageGranularity,

+        VkDeviceSize allocSize,

+        VkDeviceSize allocAlignment,

+        bool upperAddress,

+        VmaSuballocationType allocType,

+        bool canMakeOtherLost,

+        uint32_t strategy,

+        VmaAllocationRequest* pAllocationRequest);

+

+    virtual bool MakeRequestedAllocationsLost(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VmaAllocationRequest* pAllocationRequest);

+

+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);

+

+    virtual VkResult CheckCorruption(const void* pBlockData);

+

+    virtual void Alloc(

+        const VmaAllocationRequest& request,

+        VmaSuballocationType type,

+        VkDeviceSize allocSize,

+        VmaAllocation hAllocation);

+

+    virtual void Free(const VmaAllocation allocation);

+    virtual void FreeAtOffset(VkDeviceSize offset);

+

+    ////////////////////////////////////////////////////////////////////////////////

+    // For defragmentation

+

+    bool IsBufferImageGranularityConflictPossible(

+        VkDeviceSize bufferImageGranularity,

+        VmaSuballocationType& inOutPrevSuballocType) const;

+

+private:

+    friend class VmaDefragmentationAlgorithm_Generic;

+    friend class VmaDefragmentationAlgorithm_Fast;

+

+    uint32_t m_FreeCount;

+    VkDeviceSize m_SumFreeSize;

+    VmaSuballocationList m_Suballocations;

+    // Suballocations that are free and have size greater than certain threshold.

+    // Sorted by size, ascending.

+    VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;

+

+    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(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VkDeviceSize bufferImageGranularity,

+        VkDeviceSize allocSize,

+        VkDeviceSize allocAlignment,

+        VmaSuballocationType allocType,

+        VmaSuballocationList::const_iterator suballocItem,

+        bool canMakeOtherLost,

+        VkDeviceSize* pOffset,

+        size_t* itemsToMakeLostCount,

+        VkDeviceSize* pSumFreeSize,

+        VkDeviceSize* pSumItemSize) 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's suitable.

+    void RegisterFreeSuballocation(VmaSuballocationList::iterator item);

+    // Given free suballocation, it removes it from sorted list of

+    // m_FreeSuballocationsBySize if it's suitable.

+    void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);

+};

+

+/*

+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(VmaAllocator hAllocator);

+    virtual ~VmaBlockMetadata_Linear();

+    virtual void Init(VkDeviceSize size);

+

+    virtual bool Validate() const;

+    virtual size_t GetAllocationCount() const;

+    virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }

+    virtual VkDeviceSize GetUnusedRangeSizeMax() const;

+    virtual bool IsEmpty() const { return GetAllocationCount() == 0; }

+

+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;

+    virtual void AddPoolStats(VmaPoolStats& inoutStats) const;

+

+#if VMA_STATS_STRING_ENABLED

+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const;

+#endif

+

+    virtual bool CreateAllocationRequest(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VkDeviceSize bufferImageGranularity,

+        VkDeviceSize allocSize,

+        VkDeviceSize allocAlignment,

+        bool upperAddress,

+        VmaSuballocationType allocType,

+        bool canMakeOtherLost,

+        uint32_t strategy,

+        VmaAllocationRequest* pAllocationRequest);

+

+    virtual bool MakeRequestedAllocationsLost(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VmaAllocationRequest* pAllocationRequest);

+

+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);

+

+    virtual VkResult CheckCorruption(const void* pBlockData);

+

+    virtual void Alloc(

+        const VmaAllocationRequest& request,

+        VmaSuballocationType type,

+        VkDeviceSize allocSize,

+        VmaAllocation hAllocation);

+

+    virtual void Free(const VmaAllocation allocation);

+    virtual void FreeAtOffset(VkDeviceSize offset);

+

+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;

+

+    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; }

+

+    // 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;

+

+    bool ShouldCompact1st() const;

+    void CleanupAfterFree();

+

+    bool CreateAllocationRequest_LowerAddress(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VkDeviceSize bufferImageGranularity,

+        VkDeviceSize allocSize,

+        VkDeviceSize allocAlignment,

+        VmaSuballocationType allocType,

+        bool canMakeOtherLost,

+        uint32_t strategy,

+        VmaAllocationRequest* pAllocationRequest);

+    bool CreateAllocationRequest_UpperAddress(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VkDeviceSize bufferImageGranularity,

+        VkDeviceSize allocSize,

+        VkDeviceSize allocAlignment,

+        VmaSuballocationType allocType,

+        bool canMakeOtherLost,

+        uint32_t strategy,

+        VmaAllocationRequest* pAllocationRequest);

+};

+

+/*

+- 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 repoted 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(VmaAllocator hAllocator);

+    virtual ~VmaBlockMetadata_Buddy();

+    virtual void Init(VkDeviceSize size);

+

+    virtual bool Validate() const;

+    virtual size_t GetAllocationCount() const { return m_AllocationCount; }

+    virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize + GetUnusableSize(); }

+    virtual VkDeviceSize GetUnusedRangeSizeMax() const;

+    virtual bool IsEmpty() const { return m_Root->type == Node::TYPE_FREE; }

+

+    virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;

+    virtual void AddPoolStats(VmaPoolStats& inoutStats) const;

+

+#if VMA_STATS_STRING_ENABLED

+    virtual void PrintDetailedMap(class VmaJsonWriter& json) const;

+#endif

+

+    virtual bool CreateAllocationRequest(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VkDeviceSize bufferImageGranularity,

+        VkDeviceSize allocSize,

+        VkDeviceSize allocAlignment,

+        bool upperAddress,

+        VmaSuballocationType allocType,

+        bool canMakeOtherLost,

+        uint32_t strategy,

+        VmaAllocationRequest* pAllocationRequest);

+

+    virtual bool MakeRequestedAllocationsLost(

+        uint32_t currentFrameIndex,

+        uint32_t frameInUseCount,

+        VmaAllocationRequest* pAllocationRequest);

+

+    virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);

+

+    virtual VkResult CheckCorruption(const void* pBlockData) { return VK_ERROR_FEATURE_NOT_PRESENT; }

+

+    virtual void Alloc(

+        const VmaAllocationRequest& request,

+        VmaSuballocationType type,

+        VkDeviceSize allocSize,

+        VmaAllocation hAllocation);

+

+    virtual void Free(const VmaAllocation allocation) { FreeAtOffset(allocation, allocation->GetOffset()); }

+    virtual void FreeAtOffset(VkDeviceSize offset) { FreeAtOffset(VMA_NULL, offset); }

+

+private:

+    static const VkDeviceSize MIN_NODE_SIZE = 32;

+    static const size_t MAX_LEVELS = 30;

+

+    struct ValidationContext

+    {

+        size_t calculatedAllocationCount;

+        size_t calculatedFreeCount;

+        VkDeviceSize calculatedSumFreeSize;

+

+        ValidationContext() :

+            calculatedAllocationCount(0),

+            calculatedFreeCount(0),

+            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

+            {

+                VmaAllocation alloc;

+            } allocation;

+            struct

+            {

+                Node* leftChild;

+            } split;

+        };

+    };

+

+    // Size of the memory block aligned down to a power of two.

+    VkDeviceSize m_UsableSize;

+    uint32_t m_LevelCount;

+

+    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;

+    // This includes space wasted due to internal fragmentation. Doesn't include unusable size.

+    VkDeviceSize m_SumFreeSize;

+

+    VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }

+    void DeleteNode(Node* node);

+    bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;

+    uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;

+    inline VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }

+    // Alloc passed just for validation. Can be null.

+    void FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset);

+    void CalcAllocationStatInfoNode(VmaStatInfo& outInfo, 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);

+

+#if VMA_STATS_STRING_ENABLED

+    void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;

+#endif

+};

+

+/*

+Represents a single block of device memory (`VkDeviceMemory`) with all the

+data about its regions (aka suballocations, #VmaAllocation), assigned and free.

+

+Thread-safety: This class must be externally synchronized.

+*/

+class VmaDeviceMemoryBlock

+{

+    VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)

+public:

+    VmaBlockMetadata* m_pMetadata;

+

+    VmaDeviceMemoryBlock(VmaAllocator hAllocator);

+

+    ~VmaDeviceMemoryBlock()

+    {

+        VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");

+        VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);

+    }

+

+    // Always call after construction.

+    void Init(

+        VmaAllocator hAllocator,

+        VmaPool hParentPool,

+        uint32_t newMemoryTypeIndex,

+        VkDeviceMemory newMemory,

+        VkDeviceSize newSize,

+        uint32_t id,

+        uint32_t algorithm);

+    // 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; }

+

+    // 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 WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);

+    VkResult ValidateMagicValueAroundAllocation(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's 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_Mutex;

+    uint32_t m_MapCount;

+    void* m_pMappedData;

+};

+

+struct VmaPointerLess

+{

+    bool operator()(const void* lhs, const void* rhs) const

+    {

+        return lhs < rhs;

+    }

+};

+

+struct VmaDefragmentationMove

+{

+    size_t srcBlockIndex;

+    size_t dstBlockIndex;

+    VkDeviceSize srcOffset;

+    VkDeviceSize dstOffset;

+    VkDeviceSize size;

+    VmaAllocation hAllocation;

+    VmaDeviceMemoryBlock* pSrcBlock;

+    VmaDeviceMemoryBlock* pDstBlock;

+};

+

+class VmaDefragmentationAlgorithm;

+

+/*

+Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific

+Vulkan memory type.

+

+Synchronized internally with a mutex.

+*/

+struct VmaBlockVector

+{

+    VMA_CLASS_NO_COPY(VmaBlockVector)

+public:

+    VmaBlockVector(

+        VmaAllocator hAllocator,

+        VmaPool hParentPool,

+        uint32_t memoryTypeIndex,

+        VkDeviceSize preferredBlockSize,

+        size_t minBlockCount,

+        size_t maxBlockCount,

+        VkDeviceSize bufferImageGranularity,

+        uint32_t frameInUseCount,

+        bool explicitBlockSize,

+        uint32_t algorithm);

+    ~VmaBlockVector();

+

+    VkResult CreateMinBlocks();

+

+    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 GetFrameInUseCount() const { return m_FrameInUseCount; }

+    uint32_t GetAlgorithm() const { return m_Algorithm; }

+

+    void GetPoolStats(VmaPoolStats* pStats);

+

+    bool IsEmpty();

+    bool IsCorruptionDetectionEnabled() const;

+

+    VkResult Allocate(

+        uint32_t currentFrameIndex,

+        VkDeviceSize size,

+        VkDeviceSize alignment,

+        const VmaAllocationCreateInfo& createInfo,

+        VmaSuballocationType suballocType,

+        size_t allocationCount,

+        VmaAllocation* pAllocations);

+

+    void Free(const VmaAllocation hAllocation);

+

+    // Adds statistics of this BlockVector to pStats.

+    void AddStats(VmaStats* pStats);

+

+#if VMA_STATS_STRING_ENABLED

+    void PrintDetailedMap(class VmaJsonWriter& json);

+#endif

+

+    void MakePoolAllocationsLost(

+        uint32_t currentFrameIndex,

+        size_t* pLostAllocationCount);

+    VkResult CheckCorruption();

+

+    // Saves results in pCtx->res.

+    void Defragment(

+        class VmaBlockVectorDefragmentationContext* pCtx,

+        VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags,

+        VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,

+        VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,

+        VkCommandBuffer commandBuffer);

+    void DefragmentationEnd(

+        class VmaBlockVectorDefragmentationContext* pCtx,

+        uint32_t flags,

+        VmaDefragmentationStats* pStats);

+

+    uint32_t ProcessDefragmentations(

+        class VmaBlockVectorDefragmentationContext *pCtx,

+        VmaDefragmentationPassMoveInfo* pMove, uint32_t maxMoves);

+

+    void CommitDefragmentations(

+        class VmaBlockVectorDefragmentationContext *pCtx,

+        VmaDefragmentationStats* pStats);

+

+    ////////////////////////////////////////////////////////////////////////////////

+    // To be used only while the m_Mutex is locked. Used during defragmentation.

+

+    size_t GetBlockCount() const { return m_Blocks.size(); }

+    VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }

+    size_t CalcAllocationCount() const;

+    bool IsBufferImageGranularityConflictPossible() const;

+

+private:

+    friend class VmaDefragmentationAlgorithm_Generic;

+

+    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 uint32_t m_FrameInUseCount;

+    const bool m_ExplicitBlockSize;

+    const uint32_t m_Algorithm;

+    VMA_RW_MUTEX m_Mutex;

+

+    /* There can be at most one allocation that is completely empty (except when minBlockCount > 0) -

+    a hysteresis to avoid pessimistic case of alternating creation and destruction of a VkDeviceMemory. */

+    bool m_HasEmptyBlock;

+    // Incrementally sorted by sumFreeSize, ascending.

+    VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;

+    uint32_t m_NextBlockId;

+

+    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();

+

+    VkResult AllocatePage(

+        uint32_t currentFrameIndex,

+        VkDeviceSize size,

+        VkDeviceSize alignment,

+        const VmaAllocationCreateInfo& createInfo,

+        VmaSuballocationType suballocType,

+        VmaAllocation* pAllocation);

+

+    // To be used only without CAN_MAKE_OTHER_LOST flag.

+    VkResult AllocateFromBlock(

+        VmaDeviceMemoryBlock* pBlock,

+        uint32_t currentFrameIndex,

+        VkDeviceSize size,

+        VkDeviceSize alignment,

+        VmaAllocationCreateFlags allocFlags,

+        void* pUserData,

+        VmaSuballocationType suballocType,

+        uint32_t strategy,

+        VmaAllocation* pAllocation);

+

+    VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);

+

+    // Saves result to pCtx->res.

+    void ApplyDefragmentationMovesCpu(

+        class VmaBlockVectorDefragmentationContext* pDefragCtx,

+        const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves);

+    // Saves result to pCtx->res.

+    void ApplyDefragmentationMovesGpu(

+        class VmaBlockVectorDefragmentationContext* pDefragCtx,

+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+        VkCommandBuffer commandBuffer);

+

+    /*

+    Used during defragmentation. pDefragmentationStats is optional. It's in/out

+    - updated with new data.

+    */

+    void FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats);

+

+    void UpdateHasEmptyBlock();

+};

+

+struct VmaPool_T

+{

+    VMA_CLASS_NO_COPY(VmaPool_T)

+public:

+    VmaBlockVector m_BlockVector;

+

+    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;

+};

+

+/*

+Performs defragmentation:

+

+- Updates `pBlockVector->m_pMetadata`.

+- Updates allocations by calling ChangeBlockAllocation() or ChangeOffset().

+- Does not move actual data, only returns requested moves as `moves`.

+*/

+class VmaDefragmentationAlgorithm

+{

+    VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm)

+public:

+    VmaDefragmentationAlgorithm(

+        VmaAllocator hAllocator,

+        VmaBlockVector* pBlockVector,

+        uint32_t currentFrameIndex) :

+        m_hAllocator(hAllocator),

+        m_pBlockVector(pBlockVector),

+        m_CurrentFrameIndex(currentFrameIndex)

+    {

+    }

+    virtual ~VmaDefragmentationAlgorithm()

+    {

+    }

+

+    virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) = 0;

+    virtual void AddAll() = 0;

+

+    virtual VkResult Defragment(

+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+        VkDeviceSize maxBytesToMove,

+        uint32_t maxAllocationsToMove,

+        VmaDefragmentationFlags flags) = 0;

+

+    virtual VkDeviceSize GetBytesMoved() const = 0;

+    virtual uint32_t GetAllocationsMoved() const = 0;

+

+protected:

+    VmaAllocator const m_hAllocator;

+    VmaBlockVector* const m_pBlockVector;

+    const uint32_t m_CurrentFrameIndex;

+

+    struct AllocationInfo

+    {

+        VmaAllocation m_hAllocation;

+        VkBool32* m_pChanged;

+

+        AllocationInfo() :

+            m_hAllocation(VK_NULL_HANDLE),

+            m_pChanged(VMA_NULL)

+        {

+        }

+        AllocationInfo(VmaAllocation hAlloc, VkBool32* pChanged) :

+            m_hAllocation(hAlloc),

+            m_pChanged(pChanged)

+        {

+        }

+    };

+};

+

+class VmaDefragmentationAlgorithm_Generic : public VmaDefragmentationAlgorithm

+{

+    VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Generic)

+public:

+    VmaDefragmentationAlgorithm_Generic(

+        VmaAllocator hAllocator,

+        VmaBlockVector* pBlockVector,

+        uint32_t currentFrameIndex,

+        bool overlappingMoveSupported);

+    virtual ~VmaDefragmentationAlgorithm_Generic();

+

+    virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);

+    virtual void AddAll() { m_AllAllocations = true; }

+

+    virtual VkResult Defragment(

+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+        VkDeviceSize maxBytesToMove,

+        uint32_t maxAllocationsToMove,

+        VmaDefragmentationFlags flags);

+

+    virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }

+    virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }

+

+private:

+    uint32_t m_AllocationCount;

+    bool m_AllAllocations;

+

+    VkDeviceSize m_BytesMoved;

+    uint32_t m_AllocationsMoved;

+

+    struct AllocationInfoSizeGreater

+    {

+        bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const

+        {

+            return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();

+        }

+    };

+

+    struct AllocationInfoOffsetGreater

+    {

+        bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const

+        {

+            return lhs.m_hAllocation->GetOffset() > rhs.m_hAllocation->GetOffset();

+        }

+    };

+

+    struct BlockInfo

+    {

+        size_t m_OriginalBlockIndex;

+        VmaDeviceMemoryBlock* m_pBlock;

+        bool m_HasNonMovableAllocations;

+        VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;

+

+        BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :

+            m_OriginalBlockIndex(SIZE_MAX),

+            m_pBlock(VMA_NULL),

+            m_HasNonMovableAllocations(true),

+            m_Allocations(pAllocationCallbacks)

+        {

+        }

+

+        void CalcHasNonMovableAllocations()

+        {

+            const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();

+            const size_t defragmentAllocCount = m_Allocations.size();

+            m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;

+        }

+

+        void SortAllocationsBySizeDescending()

+        {

+            VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());

+        }

+

+        void SortAllocationsByOffsetDescending()

+        {

+            VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoOffsetGreater());

+        }

+    };

+

+    struct BlockPointerLess

+    {

+        bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const

+        {

+            return pLhsBlockInfo->m_pBlock < pRhsBlock;

+        }

+        bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const

+        {

+            return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;

+        }

+    };

+

+    // 1. Blocks with some non-movable allocations go first.

+    // 2. Blocks with smaller sumFreeSize go first.

+    struct BlockInfoCompareMoveDestination

+    {

+        bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const

+        {

+            if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)

+            {

+                return true;

+            }

+            if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)

+            {

+                return false;

+            }

+            if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())

+            {

+                return true;

+            }

+            return false;

+        }

+    };

+

+    typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;

+    BlockInfoVector m_Blocks;

+

+    VkResult DefragmentRound(

+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+        VkDeviceSize maxBytesToMove,

+        uint32_t maxAllocationsToMove,

+        bool freeOldAllocations);

+

+    size_t CalcBlocksWithNonMovableCount() const;

+

+    static bool MoveMakesSense(

+        size_t dstBlockIndex, VkDeviceSize dstOffset,

+        size_t srcBlockIndex, VkDeviceSize srcOffset);

+};

+

+class VmaDefragmentationAlgorithm_Fast : public VmaDefragmentationAlgorithm

+{

+    VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Fast)

+public:

+    VmaDefragmentationAlgorithm_Fast(

+        VmaAllocator hAllocator,

+        VmaBlockVector* pBlockVector,

+        uint32_t currentFrameIndex,

+        bool overlappingMoveSupported);

+    virtual ~VmaDefragmentationAlgorithm_Fast();

+

+    virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) { ++m_AllocationCount; }

+    virtual void AddAll() { m_AllAllocations = true; }

+

+    virtual VkResult Defragment(

+        VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+        VkDeviceSize maxBytesToMove,

+        uint32_t maxAllocationsToMove,

+        VmaDefragmentationFlags flags);

+

+    virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }

+    virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }

+

+private:

+    struct BlockInfo

+    {

+        size_t origBlockIndex;

+    };

+

+    class FreeSpaceDatabase

+    {

+    public:

+        FreeSpaceDatabase()

+        {

+            FreeSpace s = {};

+            s.blockInfoIndex = SIZE_MAX;

+            for(size_t i = 0; i < MAX_COUNT; ++i)

+            {

+                m_FreeSpaces[i] = s;

+            }

+        }

+

+        void Register(size_t blockInfoIndex, VkDeviceSize offset, VkDeviceSize size)

+        {

+            if(size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

+            {

+                return;

+            }

+

+            // Find first invalid or the smallest structure.

+            size_t bestIndex = SIZE_MAX;

+            for(size_t i = 0; i < MAX_COUNT; ++i)

+            {

+                // Empty structure.

+                if(m_FreeSpaces[i].blockInfoIndex == SIZE_MAX)

+                {

+                    bestIndex = i;

+                    break;

+                }

+                if(m_FreeSpaces[i].size < size &&

+                    (bestIndex == SIZE_MAX || m_FreeSpaces[bestIndex].size > m_FreeSpaces[i].size))

+                {

+                    bestIndex = i;

+                }

+            }

+

+            if(bestIndex != SIZE_MAX)

+            {

+                m_FreeSpaces[bestIndex].blockInfoIndex = blockInfoIndex;

+                m_FreeSpaces[bestIndex].offset = offset;

+                m_FreeSpaces[bestIndex].size = size;

+            }

+        }

+

+        bool Fetch(VkDeviceSize alignment, VkDeviceSize size,

+            size_t& outBlockInfoIndex, VkDeviceSize& outDstOffset)

+        {

+            size_t bestIndex = SIZE_MAX;

+            VkDeviceSize bestFreeSpaceAfter = 0;

+            for(size_t i = 0; i < MAX_COUNT; ++i)

+            {

+                // Structure is valid.

+                if(m_FreeSpaces[i].blockInfoIndex != SIZE_MAX)

+                {

+                    const VkDeviceSize dstOffset = VmaAlignUp(m_FreeSpaces[i].offset, alignment);

+                    // Allocation fits into this structure.

+                    if(dstOffset + size <= m_FreeSpaces[i].offset + m_FreeSpaces[i].size)

+                    {

+                        const VkDeviceSize freeSpaceAfter = (m_FreeSpaces[i].offset + m_FreeSpaces[i].size) -

+                            (dstOffset + size);

+                        if(bestIndex == SIZE_MAX || freeSpaceAfter > bestFreeSpaceAfter)

+                        {

+                            bestIndex = i;

+                            bestFreeSpaceAfter = freeSpaceAfter;

+                        }

+                    }

+                }

+            }

+

+            if(bestIndex != SIZE_MAX)

+            {

+                outBlockInfoIndex = m_FreeSpaces[bestIndex].blockInfoIndex;

+                outDstOffset = VmaAlignUp(m_FreeSpaces[bestIndex].offset, alignment);

+

+                if(bestFreeSpaceAfter >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

+                {

+                    // Leave this structure for remaining empty space.

+                    const VkDeviceSize alignmentPlusSize = (outDstOffset - m_FreeSpaces[bestIndex].offset) + size;

+                    m_FreeSpaces[bestIndex].offset += alignmentPlusSize;

+                    m_FreeSpaces[bestIndex].size -= alignmentPlusSize;

+                }

+                else

+                {

+                    // This structure becomes invalid.

+                    m_FreeSpaces[bestIndex].blockInfoIndex = SIZE_MAX;

+                }

+

+                return true;

+            }

+

+            return false;

+        }

+

+    private:

+        static const size_t MAX_COUNT = 4;

+

+        struct FreeSpace

+        {

+            size_t blockInfoIndex; // SIZE_MAX means this structure is invalid.

+            VkDeviceSize offset;

+            VkDeviceSize size;

+        } m_FreeSpaces[MAX_COUNT];

+    };

+

+    const bool m_OverlappingMoveSupported;

+

+    uint32_t m_AllocationCount;

+    bool m_AllAllocations;

+

+    VkDeviceSize m_BytesMoved;

+    uint32_t m_AllocationsMoved;

+

+    VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> > m_BlockInfos;

+

+    void PreprocessMetadata();

+    void PostprocessMetadata();

+    void InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc);

+};

+

+struct VmaBlockDefragmentationContext

+{

+    enum BLOCK_FLAG

+    {

+        BLOCK_FLAG_USED = 0x00000001,

+    };

+    uint32_t flags;

+    VkBuffer hBuffer;

+};

+

+class VmaBlockVectorDefragmentationContext

+{

+    VMA_CLASS_NO_COPY(VmaBlockVectorDefragmentationContext)

+public:

+    VkResult res;

+    bool mutexLocked;

+    VmaVector< VmaBlockDefragmentationContext, VmaStlAllocator<VmaBlockDefragmentationContext> > blockContexts;

+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> > defragmentationMoves;

+    uint32_t defragmentationMovesProcessed;

+    uint32_t defragmentationMovesCommitted;

+    bool hasDefragmentationPlan;

+

+    VmaBlockVectorDefragmentationContext(

+        VmaAllocator hAllocator,

+        VmaPool hCustomPool, // Optional.

+        VmaBlockVector* pBlockVector,

+        uint32_t currFrameIndex);

+    ~VmaBlockVectorDefragmentationContext();

+

+    VmaPool GetCustomPool() const { return m_hCustomPool; }

+    VmaBlockVector* GetBlockVector() const { return m_pBlockVector; }

+    VmaDefragmentationAlgorithm* GetAlgorithm() const { return m_pAlgorithm; }

+

+    void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);

+    void AddAll() { m_AllAllocations = true; }

+

+    void Begin(bool overlappingMoveSupported, VmaDefragmentationFlags flags);

+

+private:

+    const VmaAllocator m_hAllocator;

+    // Null if not from custom pool.

+    const VmaPool m_hCustomPool;

+    // Redundant, for convenience not to fetch from m_hCustomPool->m_BlockVector or m_hAllocator->m_pBlockVectors.

+    VmaBlockVector* const m_pBlockVector;

+    const uint32_t m_CurrFrameIndex;

+    // Owner of this object.

+    VmaDefragmentationAlgorithm* m_pAlgorithm;

+

+    struct AllocInfo

+    {

+        VmaAllocation hAlloc;

+        VkBool32* pChanged;

+    };

+    // Used between constructor and Begin.

+    VmaVector< AllocInfo, VmaStlAllocator<AllocInfo> > m_Allocations;

+    bool m_AllAllocations;

+};

+

+struct VmaDefragmentationContext_T

+{

+private:

+    VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)

+public:

+    VmaDefragmentationContext_T(

+        VmaAllocator hAllocator,

+        uint32_t currFrameIndex,

+        uint32_t flags,

+        VmaDefragmentationStats* pStats);

+    ~VmaDefragmentationContext_T();

+

+    void AddPools(uint32_t poolCount, const VmaPool* pPools);

+    void AddAllocations(

+        uint32_t allocationCount,

+        const VmaAllocation* pAllocations,

+        VkBool32* pAllocationsChanged);

+

+    /*

+    Returns:

+    - `VK_SUCCESS` if succeeded and object can be destroyed immediately.

+    - `VK_NOT_READY` if succeeded but the object must remain alive until vmaDefragmentationEnd().

+    - Negative value if error occured and object can be destroyed immediately.

+    */

+    VkResult Defragment(

+        VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,

+        VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,

+        VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags);

+

+    VkResult DefragmentPassBegin(VmaDefragmentationPassInfo* pInfo);

+    VkResult DefragmentPassEnd();

+

+private:

+    const VmaAllocator m_hAllocator;

+    const uint32_t m_CurrFrameIndex;

+    const uint32_t m_Flags;

+    VmaDefragmentationStats* const m_pStats;

+

+    VkDeviceSize m_MaxCpuBytesToMove;

+    uint32_t m_MaxCpuAllocationsToMove;

+    VkDeviceSize m_MaxGpuBytesToMove;

+    uint32_t m_MaxGpuAllocationsToMove;

+

+    // Owner of these objects.

+    VmaBlockVectorDefragmentationContext* m_DefaultPoolContexts[VK_MAX_MEMORY_TYPES];

+    // Owner of these objects.

+    VmaVector< VmaBlockVectorDefragmentationContext*, VmaStlAllocator<VmaBlockVectorDefragmentationContext*> > m_CustomPoolContexts;

+};

+

+#if VMA_RECORDING_ENABLED

+

+class VmaRecorder

+{

+public:

+    VmaRecorder();

+    VkResult Init(const VmaRecordSettings& settings, bool useMutex);

+    void WriteConfiguration(

+        const VkPhysicalDeviceProperties& devProps,

+        const VkPhysicalDeviceMemoryProperties& memProps,

+        uint32_t vulkanApiVersion,

+        bool dedicatedAllocationExtensionEnabled,

+        bool bindMemory2ExtensionEnabled,

+        bool memoryBudgetExtensionEnabled,

+        bool deviceCoherentMemoryExtensionEnabled);

+    ~VmaRecorder();

+

+    void RecordCreateAllocator(uint32_t frameIndex);

+    void RecordDestroyAllocator(uint32_t frameIndex);

+    void RecordCreatePool(uint32_t frameIndex,

+        const VmaPoolCreateInfo& createInfo,

+        VmaPool pool);

+    void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);

+    void RecordAllocateMemory(uint32_t frameIndex,

+        const VkMemoryRequirements& vkMemReq,

+        const VmaAllocationCreateInfo& createInfo,

+        VmaAllocation allocation);

+    void RecordAllocateMemoryPages(uint32_t frameIndex,

+        const VkMemoryRequirements& vkMemReq,

+        const VmaAllocationCreateInfo& createInfo,

+        uint64_t allocationCount,

+        const VmaAllocation* pAllocations);

+    void RecordAllocateMemoryForBuffer(uint32_t frameIndex,

+        const VkMemoryRequirements& vkMemReq,

+        bool requiresDedicatedAllocation,

+        bool prefersDedicatedAllocation,

+        const VmaAllocationCreateInfo& createInfo,

+        VmaAllocation allocation);

+    void RecordAllocateMemoryForImage(uint32_t frameIndex,

+        const VkMemoryRequirements& vkMemReq,

+        bool requiresDedicatedAllocation,

+        bool prefersDedicatedAllocation,

+        const VmaAllocationCreateInfo& createInfo,

+        VmaAllocation allocation);

+    void RecordFreeMemory(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordFreeMemoryPages(uint32_t frameIndex,

+        uint64_t allocationCount,

+        const VmaAllocation* pAllocations);

+    void RecordSetAllocationUserData(uint32_t frameIndex,

+        VmaAllocation allocation,

+        const void* pUserData);

+    void RecordCreateLostAllocation(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordMapMemory(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordUnmapMemory(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordFlushAllocation(uint32_t frameIndex,

+        VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);

+    void RecordInvalidateAllocation(uint32_t frameIndex,

+        VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);

+    void RecordCreateBuffer(uint32_t frameIndex,

+        const VkBufferCreateInfo& bufCreateInfo,

+        const VmaAllocationCreateInfo& allocCreateInfo,

+        VmaAllocation allocation);

+    void RecordCreateImage(uint32_t frameIndex,

+        const VkImageCreateInfo& imageCreateInfo,

+        const VmaAllocationCreateInfo& allocCreateInfo,

+        VmaAllocation allocation);

+    void RecordDestroyBuffer(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordDestroyImage(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordTouchAllocation(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordGetAllocationInfo(uint32_t frameIndex,

+        VmaAllocation allocation);

+    void RecordMakePoolAllocationsLost(uint32_t frameIndex,

+        VmaPool pool);

+    void RecordDefragmentationBegin(uint32_t frameIndex,

+        const VmaDefragmentationInfo2& info,

+        VmaDefragmentationContext ctx);

+    void RecordDefragmentationEnd(uint32_t frameIndex,

+        VmaDefragmentationContext ctx);

+    void RecordSetPoolName(uint32_t frameIndex,

+        VmaPool pool,

+        const char* name);

+

+private:

+    struct CallParams

+    {

+        uint32_t threadId;

+        double time;

+    };

+

+    class UserDataString

+    {

+    public:

+        UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);

+        const char* GetString() const { return m_Str; }

+

+    private:

+        char m_PtrStr[17];

+        const char* m_Str;

+    };

+

+    bool m_UseMutex;

+    VmaRecordFlags m_Flags;

+    FILE* m_File;

+    VMA_MUTEX m_FileMutex;

+    std::chrono::time_point<std::chrono::high_resolution_clock> m_RecordingStartTime;

+

+    void GetBasicParams(CallParams& outParams);

+

+    // T must be a pointer type, e.g. VmaAllocation, VmaPool.

+    template<typename T>

+    void PrintPointerList(uint64_t count, const T* pItems)

+    {

+        if(count)

+        {

+            fprintf(m_File, "%p", pItems[0]);

+            for(uint64_t i = 1; i < count; ++i)

+            {

+                fprintf(m_File, " %p", pItems[i]);

+            }

+        }

+    }

+

+    void PrintPointerList(uint64_t count, const VmaAllocation* pItems);

+    void Flush();

+};

+

+#endif // #if VMA_RECORDING_ENABLED

+

+/*

+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);

+

+    template<typename... Types> VmaAllocation Allocate(Types... args);

+    void Free(VmaAllocation hAlloc);

+

+private:

+    VMA_MUTEX m_Mutex;

+    VmaPoolAllocator<VmaAllocation_T> m_Allocator;

+};

+

+struct VmaCurrentBudgetData

+{

+    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 // #if VMA_MEMORY_BUDGET

+

+    VmaCurrentBudgetData()

+    {

+        for(uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)

+        {

+            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 AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)

+    {

+        m_AllocationBytes[heapIndex] += allocationSize;

+#if VMA_MEMORY_BUDGET

+        ++m_OperationsSinceBudgetFetch;

+#endif

+    }

+

+    void RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)

+    {

+        VMA_ASSERT(m_AllocationBytes[heapIndex] >= allocationSize); // DELME

+        m_AllocationBytes[heapIndex] -= allocationSize;

+#if VMA_MEMORY_BUDGET

+        ++m_OperationsSinceBudgetFetch;

+#endif

+    }

+};

+

+// 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;

+    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];

+

+    // Each vector is sorted by memory (handle value).

+    typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;

+    AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];

+    VMA_RW_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];

+

+    VmaCurrentBudgetData m_Budget;

+

+    VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);

+    VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);

+    ~VmaAllocator_T();

+

+    const VkAllocationCallbacks* GetAllocationCallbacks() const

+    {

+        return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;

+    }

+    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_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :

+            (VkDeviceSize)VMA_DEBUG_ALIGNMENT;

+    }

+

+    bool IsIntegratedGpu() const

+    {

+        return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;

+    }

+

+    uint32_t GetGlobalMemoryTypeBits() const { return m_GlobalMemoryTypeBits; }

+

+#if VMA_RECORDING_ENABLED

+    VmaRecorder* GetRecorder() const { return m_pRecorder; }

+#endif

+

+    void GetBufferMemoryRequirements(

+        VkBuffer hBuffer,

+        VkMemoryRequirements& memReq,

+        bool& requiresDedicatedAllocation,

+        bool& prefersDedicatedAllocation) const;

+    void GetImageMemoryRequirements(

+        VkImage hImage,

+        VkMemoryRequirements& memReq,

+        bool& requiresDedicatedAllocation,

+        bool& prefersDedicatedAllocation) const;

+

+    // Main allocation function.

+    VkResult AllocateMemory(

+        const VkMemoryRequirements& vkMemReq,

+        bool requiresDedicatedAllocation,

+        bool prefersDedicatedAllocation,

+        VkBuffer dedicatedBuffer,

+        VkBufferUsageFlags dedicatedBufferUsage, // UINT32_MAX when unknown.

+        VkImage dedicatedImage,

+        const VmaAllocationCreateInfo& createInfo,

+        VmaSuballocationType suballocType,

+        size_t allocationCount,

+        VmaAllocation* pAllocations);

+

+    // Main deallocation function.

+    void FreeMemory(

+        size_t allocationCount,

+        const VmaAllocation* pAllocations);

+

+    VkResult ResizeAllocation(

+        const VmaAllocation alloc,

+        VkDeviceSize newSize);

+

+    void CalculateStats(VmaStats* pStats);

+

+    void GetBudget(

+        VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount);

+

+#if VMA_STATS_STRING_ENABLED

+    void PrintDetailedMap(class VmaJsonWriter& json);

+#endif

+

+    VkResult DefragmentationBegin(

+        const VmaDefragmentationInfo2& info,

+        VmaDefragmentationStats* pStats,

+        VmaDefragmentationContext* pContext);

+    VkResult DefragmentationEnd(

+        VmaDefragmentationContext context);

+

+    VkResult DefragmentationPassBegin(

+        VmaDefragmentationPassInfo* pInfo,

+        VmaDefragmentationContext context);

+    VkResult DefragmentationPassEnd(

+        VmaDefragmentationContext context);

+

+    void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);

+    bool TouchAllocation(VmaAllocation hAllocation);

+

+    VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);

+    void DestroyPool(VmaPool pool);

+    void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);

+

+    void SetCurrentFrameIndex(uint32_t frameIndex);

+    uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }

+

+    void MakePoolAllocationsLost(

+        VmaPool hPool,

+        size_t* pLostAllocationCount);

+    VkResult CheckPoolCorruption(VmaPool hPool);

+    VkResult CheckCorruption(uint32_t memoryTypeBits);

+

+    void CreateLostAllocation(VmaAllocation* pAllocation);

+

+    // 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();

+

+private:

+    VkDeviceSize m_PreferredLargeHeapBlockSize;

+

+    VkPhysicalDevice m_PhysicalDevice;

+    VMA_ATOMIC_UINT32 m_CurrentFrameIndex;

+    VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.

+

+    VMA_RW_MUTEX m_PoolsMutex;

+    // Protected by m_PoolsMutex. Sorted by pointer value.

+    VmaVector<VmaPool, VmaStlAllocator<VmaPool> > 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;

+

+#if VMA_RECORDING_ENABLED

+    VmaRecorder* m_pRecorder;

+#endif

+

+    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(

+        VkDeviceSize size,

+        VkDeviceSize alignment,

+        bool dedicatedAllocation,

+        VkBuffer dedicatedBuffer,

+        VkBufferUsageFlags dedicatedBufferUsage,

+        VkImage dedicatedImage,

+        const VmaAllocationCreateInfo& createInfo,

+        uint32_t memTypeIndex,

+        VmaSuballocationType suballocType,

+        size_t allocationCount,

+        VmaAllocation* pAllocations);

+

+    // Helper function only to be used inside AllocateDedicatedMemory.

+    VkResult AllocateDedicatedMemoryPage(

+        VkDeviceSize size,

+        VmaSuballocationType suballocType,

+        uint32_t memTypeIndex,

+        const VkMemoryAllocateInfo& allocInfo,

+        bool map,

+        bool isUserDataString,

+        void* pUserData,

+        VmaAllocation* pAllocation);

+

+    // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.

+    VkResult AllocateDedicatedMemory(

+        VkDeviceSize size,

+        VmaSuballocationType suballocType,

+        uint32_t memTypeIndex,

+        bool withinBudget,

+        bool map,

+        bool isUserDataString,

+        void* pUserData,

+        VkBuffer dedicatedBuffer,

+        VkBufferUsageFlags dedicatedBufferUsage,

+        VkImage dedicatedImage,

+        size_t allocationCount,

+        VmaAllocation* pAllocations);

+

+    void FreeDedicatedMemory(const VmaAllocation allocation);

+

+    /*

+    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

+};

+

+////////////////////////////////////////////////////////////////////////////////

+// Memory allocation #2 after VmaAllocator_T definition

+

+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);

+    }

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaStringBuilder

+

+#if VMA_STATS_STRING_ENABLED

+

+class VmaStringBuilder

+{

+public:

+    VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }

+    size_t GetLength() const { return m_Data.size(); }

+    const char* GetData() const { return m_Data.data(); }

+

+    void Add(char ch) { m_Data.push_back(ch); }

+    void Add(const char* pStr);

+    void AddNewLine() { Add('\n'); }

+    void AddNumber(uint32_t num);

+    void AddNumber(uint64_t num);

+    void AddPointer(const void* ptr);

+

+private:

+    VmaVector< char, VmaStlAllocator<char> > m_Data;

+};

+

+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 // #if VMA_STATS_STRING_ENABLED

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaJsonWriter

+

+#if VMA_STATS_STRING_ENABLED

+

+class VmaJsonWriter

+{

+    VMA_CLASS_NO_COPY(VmaJsonWriter)

+public:

+    VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);

+    ~VmaJsonWriter();

+

+    void BeginObject(bool singleLine = false);

+    void EndObject();

+

+    void BeginArray(bool singleLine = false);

+    void EndArray();

+

+    void WriteString(const char* pStr);

+    void BeginString(const char* pStr = VMA_NULL);

+    void ContinueString(const char* pStr);

+    void ContinueString(uint32_t n);

+    void ContinueString(uint64_t n);

+    void ContinueString_Pointer(const void* ptr);

+    void EndString(const char* pStr = VMA_NULL);

+

+    void WriteNumber(uint32_t n);

+    void WriteNumber(uint64_t n);

+    void WriteBool(bool b);

+    void WriteNull();

+

+private:

+    static const char* const INDENT;

+

+    enum COLLECTION_TYPE

+    {

+        COLLECTION_TYPE_OBJECT,

+        COLLECTION_TYPE_ARRAY,

+    };

+    struct StackItem

+    {

+        COLLECTION_TYPE type;

+        uint32_t valueCount;

+        bool singleLineMode;

+    };

+

+    VmaStringBuilder& m_SB;

+    VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;

+    bool m_InsideString;

+

+    void BeginValue(bool isString);

+    void WriteIndent(bool oneLess = false);

+};

+

+const char* const VmaJsonWriter::INDENT = "  ";

+

+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_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::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 // #if VMA_STATS_STRING_ENABLED

+

+////////////////////////////////////////////////////////////////////////////////

+

+void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)

+{

+    if(IsUserDataString())

+    {

+        VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);

+

+        FreeUserDataString(hAllocator);

+

+        if(pUserData != VMA_NULL)

+        {

+            m_pUserData = VmaCreateStringCopy(hAllocator->GetAllocationCallbacks(), (const char*)pUserData);

+        }

+    }

+    else

+    {

+        m_pUserData = pUserData;

+    }

+}

+

+void VmaAllocation_T::ChangeBlockAllocation(

+    VmaAllocator hAllocator,

+    VmaDeviceMemoryBlock* block,

+    VkDeviceSize offset)

+{

+    VMA_ASSERT(block != VMA_NULL);

+    VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);

+

+    // Move mapping reference counter from old block to new block.

+    if(block != m_BlockAllocation.m_Block)

+    {

+        uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;

+        if(IsPersistentMap())

+            ++mapRefCount;

+        m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);

+        block->Map(hAllocator, mapRefCount, VMA_NULL);

+    }

+

+    m_BlockAllocation.m_Block = block;

+    m_BlockAllocation.m_Offset = offset;

+}

+

+void VmaAllocation_T::ChangeOffset(VkDeviceSize newOffset)

+{

+    VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);

+    m_BlockAllocation.m_Offset = newOffset;

+}

+

+VkDeviceSize VmaAllocation_T::GetOffset() const

+{

+    switch(m_Type)

+    {

+    case ALLOCATION_TYPE_BLOCK:

+        return m_BlockAllocation.m_Offset;

+    case ALLOCATION_TYPE_DEDICATED:

+        return 0;

+    default:

+        VMA_ASSERT(0);

+        return 0;

+    }

+}

+

+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)

+        {

+            void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();

+            VMA_ASSERT(pBlockData != VMA_NULL);

+            return (char*)pBlockData + m_BlockAllocation.m_Offset;

+        }

+        else

+        {

+            return VMA_NULL;

+        }

+        break;

+    case ALLOCATION_TYPE_DEDICATED:

+        VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));

+        return m_DedicatedAllocation.m_pMappedData;

+    default:

+        VMA_ASSERT(0);

+        return VMA_NULL;

+    }

+}

+

+bool VmaAllocation_T::CanBecomeLost() const

+{

+    switch(m_Type)

+    {

+    case ALLOCATION_TYPE_BLOCK:

+        return m_BlockAllocation.m_CanBecomeLost;

+    case ALLOCATION_TYPE_DEDICATED:

+        return false;

+    default:

+        VMA_ASSERT(0);

+        return false;

+    }

+}

+

+bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)

+{

+    VMA_ASSERT(CanBecomeLost());

+

+    /*

+    Warning: This is a carefully designed algorithm.

+    Do not modify unless you really know what you're doing :)

+    */

+    uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();

+    for(;;)

+    {

+        if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)

+        {

+            VMA_ASSERT(0);

+            return false;

+        }

+        else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)

+        {

+            return false;

+        }

+        else // Last use time earlier than current time.

+        {

+            if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))

+            {

+                // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.

+                // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.

+                return true;

+            }

+        }

+    }

+}

+

+#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",

+};

+

+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);

+

+    if(m_pUserData != VMA_NULL)

+    {

+        json.WriteString("UserData");

+        if(IsUserDataString())

+        {

+            json.WriteString((const char*)m_pUserData);

+        }

+        else

+        {

+            json.BeginString();

+            json.ContinueString_Pointer(m_pUserData);

+            json.EndString();

+        }

+    }

+

+    json.WriteString("CreationFrameIndex");

+    json.WriteNumber(m_CreationFrameIndex);

+

+    json.WriteString("LastUseFrameIndex");

+    json.WriteNumber(GetLastUseFrameIndex());

+

+    if(m_BufferImageUsage != 0)

+    {

+        json.WriteString("Usage");

+        json.WriteNumber(m_BufferImageUsage);

+    }

+}

+

+#endif

+

+void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)

+{

+    VMA_ASSERT(IsUserDataString());

+    VmaFreeString(hAllocator->GetAllocationCallbacks(), (char*)m_pUserData);

+    m_pUserData = VMA_NULL;

+}

+

+void VmaAllocation_T::BlockAllocMap()

+{

+    VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);

+

+    if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)

+    {

+        ++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 & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 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);

+

+    if(m_MapCount != 0)

+    {

+        if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)

+        {

+            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 & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)

+    {

+        --m_MapCount;

+        if(m_MapCount == 0)

+        {

+            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

+

+static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)

+{

+    json.BeginObject();

+

+    json.WriteString("Blocks");

+    json.WriteNumber(stat.blockCount);

+

+    json.WriteString("Allocations");

+    json.WriteNumber(stat.allocationCount);

+

+    json.WriteString("UnusedRanges");

+    json.WriteNumber(stat.unusedRangeCount);

+

+    json.WriteString("UsedBytes");

+    json.WriteNumber(stat.usedBytes);

+

+    json.WriteString("UnusedBytes");

+    json.WriteNumber(stat.unusedBytes);

+

+    if(stat.allocationCount > 1)

+    {

+        json.WriteString("AllocationSize");

+        json.BeginObject(true);

+        json.WriteString("Min");

+        json.WriteNumber(stat.allocationSizeMin);

+        json.WriteString("Avg");

+        json.WriteNumber(stat.allocationSizeAvg);

+        json.WriteString("Max");

+        json.WriteNumber(stat.allocationSizeMax);

+        json.EndObject();

+    }

+

+    if(stat.unusedRangeCount > 1)

+    {

+        json.WriteString("UnusedRangeSize");

+        json.BeginObject(true);

+        json.WriteString("Min");

+        json.WriteNumber(stat.unusedRangeSizeMin);

+        json.WriteString("Avg");

+        json.WriteNumber(stat.unusedRangeSizeAvg);

+        json.WriteString("Max");

+        json.WriteNumber(stat.unusedRangeSizeMax);

+        json.EndObject();

+    }

+

+    json.EndObject();

+}

+

+#endif // #if VMA_STATS_STRING_ENABLED

+

+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;

+    }

+};

+

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaBlockMetadata

+

+VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :

+    m_Size(0),

+    m_pAllocationCallbacks(hAllocator->GetAllocationCallbacks())

+{

+}

+

+#if VMA_STATS_STRING_ENABLED

+

+void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,

+    VkDeviceSize unusedBytes,

+    size_t allocationCount,

+    size_t unusedRangeCount) const

+{

+    json.BeginObject();

+

+    json.WriteString("TotalBytes");

+    json.WriteNumber(GetSize());

+

+    json.WriteString("UnusedBytes");

+    json.WriteNumber(unusedBytes);

+

+    json.WriteString("Allocations");

+    json.WriteNumber((uint64_t)allocationCount);

+

+    json.WriteString("UnusedRanges");

+    json.WriteNumber((uint64_t)unusedRangeCount);

+

+    json.WriteString("Suballocations");

+    json.BeginArray();

+}

+

+void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,

+    VkDeviceSize offset,

+    VmaAllocation hAllocation) const

+{

+    json.BeginObject(true);

+

+    json.WriteString("Offset");

+    json.WriteNumber(offset);

+

+    hAllocation->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();

+    json.EndObject();

+}

+

+#endif // #if VMA_STATS_STRING_ENABLED

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaBlockMetadata_Generic

+

+VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :

+    VmaBlockMetadata(hAllocator),

+    m_FreeCount(0),

+    m_SumFreeSize(0),

+    m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),

+    m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))

+{

+}

+

+VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()

+{

+}

+

+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;

+    suballoc.hAllocation = VK_NULL_HANDLE;

+

+    VMA_ASSERT(size > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);

+    m_Suballocations.push_back(suballoc);

+    VmaSuballocationList::iterator suballocItem = m_Suballocations.end();

+    --suballocItem;

+    m_FreeSuballocationsBySize.push_back(suballocItem);

+}

+

+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;

+

+    for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();

+        suballocItem != m_Suballocations.cend();

+        ++suballocItem)

+    {

+        const VmaSuballocation& subAlloc = *suballocItem;

+

+        // 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);

+

+        VMA_VALIDATE(currFree == (subAlloc.hAllocation == VK_NULL_HANDLE));

+

+        if(currFree)

+        {

+            calculatedSumFreeSize += subAlloc.size;

+            ++calculatedFreeCount;

+            if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

+            {

+                ++freeSuballocationsToRegister;

+            }

+

+            // Margin required between allocations - every free space must be at least that large.

+            VMA_VALIDATE(subAlloc.size >= VMA_DEBUG_MARGIN);

+        }

+        else

+        {

+            VMA_VALIDATE(subAlloc.hAllocation->GetOffset() == subAlloc.offset);

+            VMA_VALIDATE(subAlloc.hAllocation->GetSize() == subAlloc.size);

+

+            // Margin required between allocations - previous allocation must be free.

+            VMA_VALIDATE(VMA_DEBUG_MARGIN == 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 calculacted values.

+    VMA_VALIDATE(ValidateFreeSuballocationList());

+    VMA_VALIDATE(calculatedOffset == GetSize());

+    VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);

+    VMA_VALIDATE(calculatedFreeCount == m_FreeCount);

+

+    return true;

+}

+

+VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const

+{

+    if(!m_FreeSuballocationsBySize.empty())

+    {

+        return m_FreeSuballocationsBySize.back()->size;

+    }

+    else

+    {

+        return 0;

+    }

+}

+

+bool VmaBlockMetadata_Generic::IsEmpty() const

+{

+    return (m_Suballocations.size() == 1) && (m_FreeCount == 1);

+}

+

+void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const

+{

+    outInfo.blockCount = 1;

+

+    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();

+    outInfo.allocationCount = rangeCount - m_FreeCount;

+    outInfo.unusedRangeCount = m_FreeCount;

+

+    outInfo.unusedBytes = m_SumFreeSize;

+    outInfo.usedBytes = GetSize() - outInfo.unusedBytes;

+

+    outInfo.allocationSizeMin = UINT64_MAX;

+    outInfo.allocationSizeMax = 0;

+    outInfo.unusedRangeSizeMin = UINT64_MAX;

+    outInfo.unusedRangeSizeMax = 0;

+

+    for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();

+        suballocItem != m_Suballocations.cend();

+        ++suballocItem)

+    {

+        const VmaSuballocation& suballoc = *suballocItem;

+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)

+        {

+            outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);

+            outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);

+        }

+        else

+        {

+            outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);

+            outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);

+        }

+    }

+}

+

+void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const

+{

+    const uint32_t rangeCount = (uint32_t)m_Suballocations.size();

+

+    inoutStats.size += GetSize();

+    inoutStats.unusedSize += m_SumFreeSize;

+    inoutStats.allocationCount += rangeCount - m_FreeCount;

+    inoutStats.unusedRangeCount += m_FreeCount;

+    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());

+}

+

+#if VMA_STATS_STRING_ENABLED

+

+void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const

+{

+    PrintDetailedMap_Begin(json,

+        m_SumFreeSize, // unusedBytes

+        m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount

+        m_FreeCount); // unusedRangeCount

+

+    size_t i = 0;

+    for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();

+        suballocItem != m_Suballocations.cend();

+        ++suballocItem, ++i)

+    {

+        if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)

+        {

+            PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);

+        }

+        else

+        {

+            PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);

+        }

+    }

+

+    PrintDetailedMap_End(json);

+}

+

+#endif // #if VMA_STATS_STRING_ENABLED

+

+bool VmaBlockMetadata_Generic::CreateAllocationRequest(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VkDeviceSize bufferImageGranularity,

+    VkDeviceSize allocSize,

+    VkDeviceSize allocAlignment,

+    bool upperAddress,

+    VmaSuballocationType allocType,

+    bool canMakeOtherLost,

+    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());

+

+    pAllocationRequest->type = VmaAllocationRequestType::Normal;

+

+    // There is not enough total free space in this block to fullfill the request: Early return.

+    if(canMakeOtherLost == false &&

+        m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)

+    {

+        return false;

+    }

+

+    // New algorithm, efficiently searching freeSuballocationsBySize.

+    const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();

+    if(freeSuballocCount > 0)

+    {

+        if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)

+        {

+            // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.

+            VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(

+                m_FreeSuballocationsBySize.data(),

+                m_FreeSuballocationsBySize.data() + freeSuballocCount,

+                allocSize + 2 * VMA_DEBUG_MARGIN,

+                VmaSuballocationItemSizeLess());

+            size_t index = it - m_FreeSuballocationsBySize.data();

+            for(; index < freeSuballocCount; ++index)

+            {

+                if(CheckAllocation(

+                    currentFrameIndex,

+                    frameInUseCount,

+                    bufferImageGranularity,

+                    allocSize,

+                    allocAlignment,

+                    allocType,

+                    m_FreeSuballocationsBySize[index],

+                    false, // canMakeOtherLost

+                    &pAllocationRequest->offset,

+                    &pAllocationRequest->itemsToMakeLostCount,

+                    &pAllocationRequest->sumFreeSize,

+                    &pAllocationRequest->sumItemSize))

+                {

+                    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(

+                    currentFrameIndex,

+                    frameInUseCount,

+                    bufferImageGranularity,

+                    allocSize,

+                    allocAlignment,

+                    allocType,

+                    it,

+                    false, // canMakeOtherLost

+                    &pAllocationRequest->offset,

+                    &pAllocationRequest->itemsToMakeLostCount,

+                    &pAllocationRequest->sumFreeSize,

+                    &pAllocationRequest->sumItemSize))

+                {

+                    pAllocationRequest->item = it;

+                    return true;

+                }

+            }

+        }

+        else // WORST_FIT, FIRST_FIT

+        {

+            // Search staring from biggest suballocations.

+            for(size_t index = freeSuballocCount; index--; )

+            {

+                if(CheckAllocation(

+                    currentFrameIndex,

+                    frameInUseCount,

+                    bufferImageGranularity,

+                    allocSize,

+                    allocAlignment,

+                    allocType,

+                    m_FreeSuballocationsBySize[index],

+                    false, // canMakeOtherLost

+                    &pAllocationRequest->offset,

+                    &pAllocationRequest->itemsToMakeLostCount,

+                    &pAllocationRequest->sumFreeSize,

+                    &pAllocationRequest->sumItemSize))

+                {

+                    pAllocationRequest->item = m_FreeSuballocationsBySize[index];

+                    return true;

+                }

+            }

+        }

+    }

+

+    if(canMakeOtherLost)

+    {

+        // Brute-force algorithm. TODO: Come up with something better.

+

+        bool found = false;

+        VmaAllocationRequest tmpAllocRequest = {};

+        tmpAllocRequest.type = VmaAllocationRequestType::Normal;

+        for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();

+            suballocIt != m_Suballocations.end();

+            ++suballocIt)

+        {

+            if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||

+                suballocIt->hAllocation->CanBecomeLost())

+            {

+                if(CheckAllocation(

+                    currentFrameIndex,

+                    frameInUseCount,

+                    bufferImageGranularity,

+                    allocSize,

+                    allocAlignment,

+                    allocType,

+                    suballocIt,

+                    canMakeOtherLost,

+                    &tmpAllocRequest.offset,

+                    &tmpAllocRequest.itemsToMakeLostCount,

+                    &tmpAllocRequest.sumFreeSize,

+                    &tmpAllocRequest.sumItemSize))

+                {

+                    if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)

+                    {

+                        *pAllocationRequest = tmpAllocRequest;

+                        pAllocationRequest->item = suballocIt;

+                        break;

+                    }

+                    if(!found || tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())

+                    {

+                        *pAllocationRequest = tmpAllocRequest;

+                        pAllocationRequest->item = suballocIt;

+                        found = true;

+                    }

+                }

+            }

+        }

+

+        return found;

+    }

+

+    return false;

+}

+

+bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VmaAllocationRequest* pAllocationRequest)

+{

+    VMA_ASSERT(pAllocationRequest && pAllocationRequest->type == VmaAllocationRequestType::Normal);

+

+    while(pAllocationRequest->itemsToMakeLostCount > 0)

+    {

+        if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)

+        {

+            ++pAllocationRequest->item;

+        }

+        VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());

+        VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);

+        VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());

+        if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))

+        {

+            pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);

+            --pAllocationRequest->itemsToMakeLostCount;

+        }

+        else

+        {

+            return false;

+        }

+    }

+

+    VMA_HEAVY_ASSERT(Validate());

+    VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());

+    VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);

+

+    return true;

+}

+

+uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)

+{

+    uint32_t lostAllocationCount = 0;

+    for(VmaSuballocationList::iterator it = m_Suballocations.begin();

+        it != m_Suballocations.end();

+        ++it)

+    {

+        if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&

+            it->hAllocation->CanBecomeLost() &&

+            it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))

+        {

+            it = FreeSuballocation(it);

+            ++lostAllocationCount;

+        }

+    }

+    return lostAllocationCount;

+}

+

+VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)

+{

+    for(VmaSuballocationList::iterator it = m_Suballocations.begin();

+        it != m_Suballocations.end();

+        ++it)

+    {

+        if(it->type != VMA_SUBALLOCATION_TYPE_FREE)

+        {

+            if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))

+            {

+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");

+                return VK_ERROR_VALIDATION_FAILED_EXT;

+            }

+            if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))

+            {

+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");

+                return VK_ERROR_VALIDATION_FAILED_EXT;

+            }

+        }

+    }

+

+    return VK_SUCCESS;

+}

+

+void VmaBlockMetadata_Generic::Alloc(

+    const VmaAllocationRequest& request,

+    VmaSuballocationType type,

+    VkDeviceSize allocSize,

+    VmaAllocation hAllocation)

+{

+    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(request.offset >= suballoc.offset);

+    const VkDeviceSize paddingBegin = request.offset - suballoc.offset;

+    VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);

+    const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;

+

+    // Unregister this free suballocation from m_FreeSuballocationsBySize and update

+    // it to become used.

+    UnregisterFreeSuballocation(request.item);

+

+    suballoc.offset = request.offset;

+    suballoc.size = allocSize;

+    suballoc.type = type;

+    suballoc.hAllocation = hAllocation;

+

+    // If there are any free bytes remaining at the end, insert new free suballocation after current one.

+    if(paddingEnd)

+    {

+        VmaSuballocation paddingSuballoc = {};

+        paddingSuballoc.offset = request.offset + allocSize;

+        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 = request.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 -= allocSize;

+}

+

+void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)

+{

+    for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();

+        suballocItem != m_Suballocations.end();

+        ++suballocItem)

+    {

+        VmaSuballocation& suballoc = *suballocItem;

+        if(suballoc.hAllocation == allocation)

+        {

+            FreeSuballocation(suballocItem);

+            VMA_HEAVY_ASSERT(Validate());

+            return;

+        }

+    }

+    VMA_ASSERT(0 && "Not found!");

+}

+

+void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)

+{

+    for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();

+        suballocItem != m_Suballocations.end();

+        ++suballocItem)

+    {

+        VmaSuballocation& suballoc = *suballocItem;

+        if(suballoc.offset == offset)

+        {

+            FreeSuballocation(suballocItem);

+            return;

+        }

+    }

+    VMA_ASSERT(0 && "Not found!");

+}

+

+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 >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);

+        VMA_VALIDATE(it->size >= lastSize);

+        lastSize = it->size;

+    }

+    return true;

+}

+

+bool VmaBlockMetadata_Generic::CheckAllocation(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VkDeviceSize bufferImageGranularity,

+    VkDeviceSize allocSize,

+    VkDeviceSize allocAlignment,

+    VmaSuballocationType allocType,

+    VmaSuballocationList::const_iterator suballocItem,

+    bool canMakeOtherLost,

+    VkDeviceSize* pOffset,

+    size_t* itemsToMakeLostCount,

+    VkDeviceSize* pSumFreeSize,

+    VkDeviceSize* pSumItemSize) const

+{

+    VMA_ASSERT(allocSize > 0);

+    VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);

+    VMA_ASSERT(suballocItem != m_Suballocations.cend());

+    VMA_ASSERT(pOffset != VMA_NULL);

+

+    *itemsToMakeLostCount = 0;

+    *pSumFreeSize = 0;

+    *pSumItemSize = 0;

+

+    if(canMakeOtherLost)

+    {

+        if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)

+        {

+            *pSumFreeSize = suballocItem->size;

+        }

+        else

+        {

+            if(suballocItem->hAllocation->CanBecomeLost() &&

+                suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)

+            {

+                ++*itemsToMakeLostCount;

+                *pSumItemSize = suballocItem->size;

+            }

+            else

+            {

+                return false;

+            }

+        }

+

+        // Remaining size is too small for this request: Early return.

+        if(GetSize() - suballocItem->offset < allocSize)

+        {

+            return false;

+        }

+

+        // Start from offset equal to beginning of this suballocation.

+        *pOffset = suballocItem->offset;

+

+        // Apply VMA_DEBUG_MARGIN at the beginning.

+        if(VMA_DEBUG_MARGIN > 0)

+        {

+            *pOffset += VMA_DEBUG_MARGIN;

+        }

+

+        // Apply alignment.

+        *pOffset = VmaAlignUp(*pOffset, allocAlignment);

+

+        // Check previous suballocations for BufferImageGranularity conflicts.

+        // Make bigger alignment if necessary.

+        if(bufferImageGranularity > 1)

+        {

+            bool bufferImageGranularityConflict = false;

+            VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;

+            while(prevSuballocItem != m_Suballocations.cbegin())

+            {

+                --prevSuballocItem;

+                const VmaSuballocation& prevSuballoc = *prevSuballocItem;

+                if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))

+                {

+                    if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))

+                    {

+                        bufferImageGranularityConflict = true;

+                        break;

+                    }

+                }

+                else

+                    // Already on previous page.

+                    break;

+            }

+            if(bufferImageGranularityConflict)

+            {

+                *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);

+            }

+        }

+

+        // Now that we have final *pOffset, check if we are past suballocItem.

+        // If yes, return false - this function should be called for another suballocItem as starting point.

+        if(*pOffset >= suballocItem->offset + suballocItem->size)

+        {

+            return false;

+        }

+

+        // Calculate padding at the beginning based on current offset.

+        const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;

+

+        // Calculate required margin at the end.

+        const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;

+

+        const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;

+        // Another early return check.

+        if(suballocItem->offset + totalSize > GetSize())

+        {

+            return false;

+        }

+

+        // Advance lastSuballocItem until desired size is reached.

+        // Update itemsToMakeLostCount.

+        VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;

+        if(totalSize > suballocItem->size)

+        {

+            VkDeviceSize remainingSize = totalSize - suballocItem->size;

+            while(remainingSize > 0)

+            {

+                ++lastSuballocItem;

+                if(lastSuballocItem == m_Suballocations.cend())

+                {

+                    return false;

+                }

+                if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)

+                {

+                    *pSumFreeSize += lastSuballocItem->size;

+                }

+                else

+                {

+                    VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);

+                    if(lastSuballocItem->hAllocation->CanBecomeLost() &&

+                        lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)

+                    {

+                        ++*itemsToMakeLostCount;

+                        *pSumItemSize += lastSuballocItem->size;

+                    }

+                    else

+                    {

+                        return false;

+                    }

+                }

+                remainingSize = (lastSuballocItem->size < remainingSize) ?

+                    remainingSize - lastSuballocItem->size : 0;

+            }

+        }

+

+        // Check next suballocations for BufferImageGranularity conflicts.

+        // If conflict exists, we must mark more allocations lost or fail.

+        if(bufferImageGranularity > 1)

+        {

+            VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;

+            ++nextSuballocItem;

+            while(nextSuballocItem != m_Suballocations.cend())

+            {

+                const VmaSuballocation& nextSuballoc = *nextSuballocItem;

+                if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))

+                {

+                    if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))

+                    {

+                        VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);

+                        if(nextSuballoc.hAllocation->CanBecomeLost() &&

+                            nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)

+                        {

+                            ++*itemsToMakeLostCount;

+                        }

+                        else

+                        {

+                            return false;

+                        }

+                    }

+                }

+                else

+                {

+                    // Already on next page.

+                    break;

+                }

+                ++nextSuballocItem;

+            }

+        }

+    }

+    else

+    {

+        const VmaSuballocation& suballoc = *suballocItem;

+        VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);

+

+        *pSumFreeSize = suballoc.size;

+

+        // 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.

+        *pOffset = suballoc.offset;

+

+        // Apply VMA_DEBUG_MARGIN at the beginning.

+        if(VMA_DEBUG_MARGIN > 0)

+        {

+            *pOffset += VMA_DEBUG_MARGIN;

+        }

+

+        // Apply alignment.

+        *pOffset = VmaAlignUp(*pOffset, allocAlignment);

+

+        // Check previous suballocations for BufferImageGranularity conflicts.

+        // Make bigger alignment if necessary.

+        if(bufferImageGranularity > 1)

+        {

+            bool bufferImageGranularityConflict = false;

+            VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;

+            while(prevSuballocItem != m_Suballocations.cbegin())

+            {

+                --prevSuballocItem;

+                const VmaSuballocation& prevSuballoc = *prevSuballocItem;

+                if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))

+                {

+                    if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))

+                    {

+                        bufferImageGranularityConflict = true;

+                        break;

+                    }

+                }

+                else

+                    // Already on previous page.

+                    break;

+            }

+            if(bufferImageGranularityConflict)

+            {

+                *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);

+            }

+        }

+

+        // Calculate padding at the beginning based on current offset.

+        const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;

+

+        // Calculate required margin at the end.

+        const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;

+

+        // Fail if requested size plus margin before and after is bigger than size of this suballocation.

+        if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)

+        {

+            return false;

+        }

+

+        // Check next suballocations for BufferImageGranularity conflicts.

+        // If conflict exists, allocation cannot be made here.

+        if(bufferImageGranularity > 1)

+        {

+            VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;

+            ++nextSuballocItem;

+            while(nextSuballocItem != m_Suballocations.cend())

+            {

+                const VmaSuballocation& nextSuballoc = *nextSuballocItem;

+                if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))

+                {

+                    if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))

+                    {

+                        return false;

+                    }

+                }

+                else

+                {

+                    // Already on next page.

+                    break;

+                }

+                ++nextSuballocItem;

+            }

+        }

+    }

+

+    // All tests passed: Success. pOffset 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.hAllocation = VK_NULL_HANDLE;

+

+    // 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(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

+    {

+        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());

+

+    if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

+    {

+        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());

+}

+

+bool VmaBlockMetadata_Generic::IsBufferImageGranularityConflictPossible(

+    VkDeviceSize bufferImageGranularity,

+    VmaSuballocationType& inOutPrevSuballocType) const

+{

+    if(bufferImageGranularity == 1 || IsEmpty())

+    {

+        return false;

+    }

+

+    VkDeviceSize minAlignment = VK_WHOLE_SIZE;

+    bool typeConflictFound = false;

+    for(VmaSuballocationList::const_iterator it = m_Suballocations.cbegin();

+        it != m_Suballocations.cend();

+        ++it)

+    {

+        const VmaSuballocationType suballocType = it->type;

+        if(suballocType != VMA_SUBALLOCATION_TYPE_FREE)

+        {

+            minAlignment = VMA_MIN(minAlignment, it->hAllocation->GetAlignment());

+            if(VmaIsBufferImageGranularityConflict(inOutPrevSuballocType, suballocType))

+            {

+                typeConflictFound = true;

+            }

+            inOutPrevSuballocType = suballocType;

+        }

+    }

+

+    return typeConflictFound || minAlignment >= bufferImageGranularity;

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaBlockMetadata_Linear

+

+VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :

+    VmaBlockMetadata(hAllocator),

+    m_SumFreeSize(0),

+    m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),

+    m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),

+    m_1stVectorIndex(0),

+    m_2ndVectorMode(SECOND_VECTOR_EMPTY),

+    m_1stNullItemsBeginCount(0),

+    m_1stNullItemsMiddleCount(0),

+    m_2ndNullItemsCount(0)

+{

+}

+

+VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()

+{

+}

+

+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].hAllocation != VK_NULL_HANDLE);

+        // Null item at the end should be just pop_back().

+        VMA_VALIDATE(suballocations1st.back().hAllocation != VK_NULL_HANDLE);

+    }

+    if(!suballocations2nd.empty())

+    {

+        // Null item at the end should be just pop_back().

+        VMA_VALIDATE(suballocations2nd.back().hAllocation != VK_NULL_HANDLE);

+    }

+

+    VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());

+    VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());

+

+    VkDeviceSize sumUsedSize = 0;

+    const size_t suballoc1stCount = suballocations1st.size();

+    VkDeviceSize offset = VMA_DEBUG_MARGIN;

+

+    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);

+

+            VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));

+            VMA_VALIDATE(suballoc.offset >= offset);

+

+            if(!currFree)

+            {

+                VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);

+                VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);

+                sumUsedSize += suballoc.size;

+            }

+            else

+            {

+                ++nullItem2ndCount;

+            }

+

+            offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;

+        }

+

+        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.hAllocation == VK_NULL_HANDLE);

+    }

+

+    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);

+

+        VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));

+        VMA_VALIDATE(suballoc.offset >= offset);

+        VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);

+

+        if(!currFree)

+        {

+            VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);

+            VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);

+            sumUsedSize += suballoc.size;

+        }

+        else

+        {

+            ++nullItem1stCount;

+        }

+

+        offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;

+    }

+    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);

+

+            VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));

+            VMA_VALIDATE(suballoc.offset >= offset);

+

+            if(!currFree)

+            {

+                VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);

+                VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);

+                sumUsedSize += suballoc.size;

+            }

+            else

+            {

+                ++nullItem2ndCount;

+            }

+

+            offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;

+        }

+

+        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;

+}

+

+VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const

+{

+    const VkDeviceSize size = GetSize();

+

+    /*

+    We don't consider gaps inside allocation vectors with freed allocations because

+    they are not suitable for reuse in linear allocator. We consider only space that

+    is available for new allocations.

+    */

+    if(IsEmpty())

+    {

+        return size;

+    }

+

+    const SuballocationVectorType& suballocations1st = AccessSuballocations1st();

+

+    switch(m_2ndVectorMode)

+    {

+    case SECOND_VECTOR_EMPTY:

+        /*

+        Available space is after end of 1st, as well as before beginning of 1st (which

+        whould make it a ring buffer).

+        */

+        {

+            const size_t suballocations1stCount = suballocations1st.size();

+            VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);

+            const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];

+            const VmaSuballocation& lastSuballoc  = suballocations1st[suballocations1stCount - 1];

+            return VMA_MAX(

+                firstSuballoc.offset,

+                size - (lastSuballoc.offset + lastSuballoc.size));

+        }

+        break;

+

+    case SECOND_VECTOR_RING_BUFFER:

+        /*

+        Available space is only between end of 2nd and beginning of 1st.

+        */

+        {

+            const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

+            const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();

+            const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];

+            return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);

+        }

+        break;

+

+    case SECOND_VECTOR_DOUBLE_STACK:

+        /*

+        Available space is only between end of 1st and top of 2nd.

+        */

+        {

+            const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

+            const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();

+            const VmaSuballocation& lastSuballoc1st = suballocations1st.back();

+            return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);

+        }

+        break;

+

+    default:

+        VMA_ASSERT(0);

+        return 0;

+    }

+}

+

+void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) 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();

+

+    outInfo.blockCount = 1;

+    outInfo.allocationCount = (uint32_t)GetAllocationCount();

+    outInfo.unusedRangeCount = 0;

+    outInfo.usedBytes = 0;

+    outInfo.allocationSizeMin = UINT64_MAX;

+    outInfo.allocationSizeMax = 0;

+    outInfo.unusedRangeSizeMin = UINT64_MAX;

+    outInfo.unusedRangeSizeMax = 0;

+

+    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].hAllocation == VK_NULL_HANDLE)

+            {

+                ++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;

+                    ++outInfo.unusedRangeCount;

+                    outInfo.unusedBytes += unusedRangeSize;

+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);

+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);

+                }

+

+                // 2. Process this allocation.

+                // There is allocation with suballoc.offset, suballoc.size.

+                outInfo.usedBytes += suballoc.size;

+                outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);

+                outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, 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;

+                    ++outInfo.unusedRangeCount;

+                    outInfo.unusedBytes += unusedRangeSize;

+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);

+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, 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].hAllocation == VK_NULL_HANDLE)

+        {

+            ++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;

+                ++outInfo.unusedRangeCount;

+                outInfo.unusedBytes += unusedRangeSize;

+                outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);

+                outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);

+            }

+

+            // 2. Process this allocation.

+            // There is allocation with suballoc.offset, suballoc.size.

+            outInfo.usedBytes += suballoc.size;

+            outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);

+            outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, 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;

+                ++outInfo.unusedRangeCount;

+                outInfo.unusedBytes += unusedRangeSize;

+                outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);

+                outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, 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].hAllocation == VK_NULL_HANDLE)

+            {

+                --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;

+                    ++outInfo.unusedRangeCount;

+                    outInfo.unusedBytes += unusedRangeSize;

+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);

+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);

+                }

+

+                // 2. Process this allocation.

+                // There is allocation with suballoc.offset, suballoc.size.

+                outInfo.usedBytes += suballoc.size;

+                outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);

+                outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, 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;

+                    ++outInfo.unusedRangeCount;

+                    outInfo.unusedBytes += unusedRangeSize;

+                    outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);

+                    outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);

+               }

+

+                // End of loop.

+                lastOffset = size;

+            }

+        }

+    }

+

+    outInfo.unusedBytes = size - outInfo.usedBytes;

+}

+

+void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& 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.size += size;

+

+    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].hAllocation == VK_NULL_HANDLE)

+            {

+                ++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;

+                    inoutStats.unusedSize += unusedRangeSize;

+                    ++inoutStats.unusedRangeCount;

+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);

+                }

+

+                // 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;

+                    inoutStats.unusedSize += unusedRangeSize;

+                    ++inoutStats.unusedRangeCount;

+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, 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].hAllocation == VK_NULL_HANDLE)

+        {

+            ++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;

+                inoutStats.unusedSize += unusedRangeSize;

+                ++inoutStats.unusedRangeCount;

+                inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);

+            }

+

+            // 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;

+                inoutStats.unusedSize += unusedRangeSize;

+                ++inoutStats.unusedRangeCount;

+                inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, 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].hAllocation == VK_NULL_HANDLE)

+            {

+                --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;

+                    inoutStats.unusedSize += unusedRangeSize;

+                    ++inoutStats.unusedRangeCount;

+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);

+                }

+

+                // 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;

+                    inoutStats.unusedSize += unusedRangeSize;

+                    ++inoutStats.unusedRangeCount;

+                    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);

+                }

+

+                // 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].hAllocation == VK_NULL_HANDLE)

+            {

+                ++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].hAllocation == VK_NULL_HANDLE)

+        {

+            ++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].hAllocation == VK_NULL_HANDLE)

+            {

+                --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].hAllocation == VK_NULL_HANDLE)

+            {

+                ++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.hAllocation);

+

+                // 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].hAllocation == VK_NULL_HANDLE)

+        {

+            ++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.hAllocation);

+

+            // 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].hAllocation == VK_NULL_HANDLE)

+            {

+                --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.hAllocation);

+

+                // 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 // #if VMA_STATS_STRING_ENABLED

+

+bool VmaBlockMetadata_Linear::CreateAllocationRequest(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VkDeviceSize bufferImageGranularity,

+    VkDeviceSize allocSize,

+    VkDeviceSize allocAlignment,

+    bool upperAddress,

+    VmaSuballocationType allocType,

+    bool canMakeOtherLost,

+    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());

+    return upperAddress ?

+        CreateAllocationRequest_UpperAddress(

+            currentFrameIndex, frameInUseCount, bufferImageGranularity,

+            allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest) :

+        CreateAllocationRequest_LowerAddress(

+            currentFrameIndex, frameInUseCount, bufferImageGranularity,

+            allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest);

+}

+

+bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VkDeviceSize bufferImageGranularity,

+    VkDeviceSize allocSize,

+    VkDeviceSize allocAlignment,

+    VmaSuballocationType allocType,

+    bool canMakeOtherLost,

+    uint32_t strategy,

+    VmaAllocationRequest* pAllocationRequest)

+{

+    const VkDeviceSize size = GetSize();

+    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 > size)

+    {

+        return false;

+    }

+    VkDeviceSize resultBaseOffset = size - 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;

+

+    // Apply VMA_DEBUG_MARGIN at the end.

+    if(VMA_DEBUG_MARGIN > 0)

+    {

+        if(resultOffset < VMA_DEBUG_MARGIN)

+        {

+            return false;

+        }

+        resultOffset -= VMA_DEBUG_MARGIN;

+    }

+

+    // Apply alignment.

+    resultOffset = VmaAlignDown(resultOffset, allocAlignment);

+

+    // Check next suballocations from 2nd for BufferImageGranularity conflicts.

+    // Make bigger alignment if necessary.

+    if(bufferImageGranularity > 1 && !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 + VMA_DEBUG_MARGIN <= 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->offset = resultOffset;

+        pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;

+        pAllocationRequest->sumItemSize = 0;

+        // pAllocationRequest->item unused.

+        pAllocationRequest->itemsToMakeLostCount = 0;

+        pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;

+        return true;

+    }

+

+    return false;

+}

+

+bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VkDeviceSize bufferImageGranularity,

+    VkDeviceSize allocSize,

+    VkDeviceSize allocAlignment,

+    VmaSuballocationType allocType,

+    bool canMakeOtherLost,

+    uint32_t strategy,

+    VmaAllocationRequest* pAllocationRequest)

+{

+    const VkDeviceSize size = GetSize();

+    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;

+        }

+

+        // Start from offset equal to beginning of free space.

+        VkDeviceSize resultOffset = resultBaseOffset;

+

+        // Apply VMA_DEBUG_MARGIN at the beginning.

+        if(VMA_DEBUG_MARGIN > 0)

+        {

+            resultOffset += VMA_DEBUG_MARGIN;

+        }

+

+        // Apply alignment.

+        resultOffset = VmaAlignUp(resultOffset, allocAlignment);

+

+        // Check previous suballocations for BufferImageGranularity conflicts.

+        // Make bigger alignment if necessary.

+        if(bufferImageGranularity > 1 && !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 : size;

+

+        // There is enough free space at the end after alignment.

+        if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)

+        {

+            // Check next suballocations for BufferImageGranularity conflicts.

+            // If conflict exists, allocation cannot be made here.

+            if(bufferImageGranularity > 1 && 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->offset = resultOffset;

+            pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;

+            pAllocationRequest->sumItemSize = 0;

+            // pAllocationRequest->item, customData unused.

+            pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;

+            pAllocationRequest->itemsToMakeLostCount = 0;

+            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;

+        }

+

+        // Start from offset equal to beginning of free space.

+        VkDeviceSize resultOffset = resultBaseOffset;

+

+        // Apply VMA_DEBUG_MARGIN at the beginning.

+        if(VMA_DEBUG_MARGIN > 0)

+        {

+            resultOffset += VMA_DEBUG_MARGIN;

+        }

+

+        // Apply alignment.

+        resultOffset = VmaAlignUp(resultOffset, allocAlignment);

+

+        // Check previous suballocations for BufferImageGranularity conflicts.

+        // Make bigger alignment if necessary.

+        if(bufferImageGranularity > 1 && !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);

+            }

+        }

+

+        pAllocationRequest->itemsToMakeLostCount = 0;

+        pAllocationRequest->sumItemSize = 0;

+        size_t index1st = m_1stNullItemsBeginCount;

+

+        if(canMakeOtherLost)

+        {

+            while(index1st < suballocations1st.size() &&

+                resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)

+            {

+                // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.

+                const VmaSuballocation& suballoc = suballocations1st[index1st];

+                if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)

+                {

+                    // No problem.

+                }

+                else

+                {

+                    VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);

+                    if(suballoc.hAllocation->CanBecomeLost() &&

+                        suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)

+                    {

+                        ++pAllocationRequest->itemsToMakeLostCount;

+                        pAllocationRequest->sumItemSize += suballoc.size;

+                    }

+                    else

+                    {

+                        return false;

+                    }

+                }

+                ++index1st;

+            }

+

+            // Check next suballocations for BufferImageGranularity conflicts.

+            // If conflict exists, we must mark more allocations lost or fail.

+            if(bufferImageGranularity > 1)

+            {

+                while(index1st < suballocations1st.size())

+                {

+                    const VmaSuballocation& suballoc = suballocations1st[index1st];

+                    if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))

+                    {

+                        if(suballoc.hAllocation != VK_NULL_HANDLE)

+                        {

+                            // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).

+                            if(suballoc.hAllocation->CanBecomeLost() &&

+                                suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)

+                            {

+                                ++pAllocationRequest->itemsToMakeLostCount;

+                                pAllocationRequest->sumItemSize += suballoc.size;

+                            }

+                            else

+                            {

+                                return false;

+                            }

+                        }

+                    }

+                    else

+                    {

+                        // Already on next page.

+                        break;

+                    }

+                    ++index1st;

+                }

+            }

+

+            // Special case: There is not enough room at the end for this allocation, even after making all from the 1st lost.

+            if(index1st == suballocations1st.size() &&

+                resultOffset + allocSize + VMA_DEBUG_MARGIN > size)

+            {

+                // TODO: This is a known bug that it's not yet implemented and the allocation is failing.

+                VMA_DEBUG_LOG("Unsupported special case in custom pool with linear allocation algorithm used as ring buffer with allocations that can be lost.");

+            }

+        }

+

+        // There is enough free space at the end after alignment.

+        if((index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= size) ||

+            (index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset))

+        {

+            // Check next suballocations for BufferImageGranularity conflicts.

+            // If conflict exists, allocation cannot be made here.

+            if(bufferImageGranularity > 1)

+            {

+                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->offset = resultOffset;

+            pAllocationRequest->sumFreeSize =

+                (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)

+                - resultBaseOffset

+                - pAllocationRequest->sumItemSize;

+            pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;

+            // pAllocationRequest->item, customData unused.

+            return true;

+        }

+    }

+

+    return false;

+}

+

+bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VmaAllocationRequest* pAllocationRequest)

+{

+    if(pAllocationRequest->itemsToMakeLostCount == 0)

+    {

+        return true;

+    }

+

+    VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);

+

+    // We always start from 1st.

+    SuballocationVectorType* suballocations = &AccessSuballocations1st();

+    size_t index = m_1stNullItemsBeginCount;

+    size_t madeLostCount = 0;

+    while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)

+    {

+        if(index == suballocations->size())

+        {

+            index = 0;

+            // If we get to the end of 1st, we wrap around to beginning of 2nd of 1st.

+            if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)

+            {

+                suballocations = &AccessSuballocations2nd();

+            }

+            // else: m_2ndVectorMode == SECOND_VECTOR_EMPTY:

+            // suballocations continues pointing at AccessSuballocations1st().

+            VMA_ASSERT(!suballocations->empty());

+        }

+        VmaSuballocation& suballoc = (*suballocations)[index];

+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)

+        {

+            VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);

+            VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());

+            if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))

+            {

+                suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;

+                suballoc.hAllocation = VK_NULL_HANDLE;

+                m_SumFreeSize += suballoc.size;

+                if(suballocations == &AccessSuballocations1st())

+                {

+                    ++m_1stNullItemsMiddleCount;

+                }

+                else

+                {

+                    ++m_2ndNullItemsCount;

+                }

+                ++madeLostCount;

+            }

+            else

+            {

+                return false;

+            }

+        }

+        ++index;

+    }

+

+    CleanupAfterFree();

+    //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().

+

+    return true;

+}

+

+uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)

+{

+    uint32_t lostAllocationCount = 0;

+

+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();

+    for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)

+    {

+        VmaSuballocation& suballoc = suballocations1st[i];

+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&

+            suballoc.hAllocation->CanBecomeLost() &&

+            suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))

+        {

+            suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;

+            suballoc.hAllocation = VK_NULL_HANDLE;

+            ++m_1stNullItemsMiddleCount;

+            m_SumFreeSize += suballoc.size;

+            ++lostAllocationCount;

+        }

+    }

+

+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

+    for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)

+    {

+        VmaSuballocation& suballoc = suballocations2nd[i];

+        if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&

+            suballoc.hAllocation->CanBecomeLost() &&

+            suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))

+        {

+            suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;

+            suballoc.hAllocation = VK_NULL_HANDLE;

+            ++m_2ndNullItemsCount;

+            m_SumFreeSize += suballoc.size;

+            ++lostAllocationCount;

+        }

+    }

+

+    if(lostAllocationCount)

+    {

+        CleanupAfterFree();

+    }

+

+    return lostAllocationCount;

+}

+

+VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)

+{

+    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 - VMA_DEBUG_MARGIN))

+            {

+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");

+                return VK_ERROR_VALIDATION_FAILED_EXT;

+            }

+            if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))

+            {

+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");

+                return VK_ERROR_VALIDATION_FAILED_EXT;

+            }

+        }

+    }

+

+    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 - VMA_DEBUG_MARGIN))

+            {

+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");

+                return VK_ERROR_VALIDATION_FAILED_EXT;

+            }

+            if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))

+            {

+                VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");

+                return VK_ERROR_VALIDATION_FAILED_EXT;

+            }

+        }

+    }

+

+    return VK_SUCCESS;

+}

+

+void VmaBlockMetadata_Linear::Alloc(

+    const VmaAllocationRequest& request,

+    VmaSuballocationType type,

+    VkDeviceSize allocSize,

+    VmaAllocation hAllocation)

+{

+    const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, 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() ||

+                request.offset >= suballocations1st.back().offset + suballocations1st.back().size);

+            // Check if it fits before the end of the block.

+            VMA_ASSERT(request.offset + allocSize <= 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() &&

+                request.offset + allocSize <= 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(const VmaAllocation allocation)

+{

+    FreeAtOffset(allocation->GetOffset());

+}

+

+void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)

+{

+    SuballocationVectorType& suballocations1st = AccessSuballocations1st();

+    SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();

+

+    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.hAllocation = VK_NULL_HANDLE;

+            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;

+        }

+    }

+

+    // Item from the middle of 1st vector.

+    {

+        VmaSuballocation refSuballoc;

+        refSuballoc.offset = offset;

+        // Rest of members stays uninitialized intentionally for better performance.

+        SuballocationVectorType::iterator it = VmaBinaryFindSorted(

+            suballocations1st.begin() + m_1stNullItemsBeginCount,

+            suballocations1st.end(),

+            refSuballoc,

+            VmaSuballocationOffsetLess());

+        if(it != suballocations1st.end())

+        {

+            it->type = VMA_SUBALLOCATION_TYPE_FREE;

+            it->hAllocation = VK_NULL_HANDLE;

+            ++m_1stNullItemsMiddleCount;

+            m_SumFreeSize += it->size;

+            CleanupAfterFree();

+            return;

+        }

+    }

+

+    if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)

+    {

+        // Item from the middle of 2nd vector.

+        VmaSuballocation refSuballoc;

+        refSuballoc.offset = offset;

+        // Rest of members stays uninitialized intentionally for better performance.

+        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->hAllocation = VK_NULL_HANDLE;

+            ++m_2ndNullItemsCount;

+            m_SumFreeSize += it->size;

+            CleanupAfterFree();

+            return;

+        }

+    }

+

+    VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");

+}

+

+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].hAllocation == VK_NULL_HANDLE)

+        {

+            ++m_1stNullItemsBeginCount;

+            --m_1stNullItemsMiddleCount;

+        }

+

+        // Find more null items at the end of 1st vector.

+        while(m_1stNullItemsMiddleCount > 0 &&

+            suballocations1st.back().hAllocation == VK_NULL_HANDLE)

+        {

+            --m_1stNullItemsMiddleCount;

+            suballocations1st.pop_back();

+        }

+

+        // Find more null items at the end of 2nd vector.

+        while(m_2ndNullItemsCount > 0 &&

+            suballocations2nd.back().hAllocation == VK_NULL_HANDLE)

+        {

+            --m_2ndNullItemsCount;

+            suballocations2nd.pop_back();

+        }

+

+        // Find more null items at the beginning of 2nd vector.

+        while(m_2ndNullItemsCount > 0 &&

+            suballocations2nd[0].hAllocation == VK_NULL_HANDLE)

+        {

+            --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].hAllocation == VK_NULL_HANDLE)

+                {

+                    ++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].hAllocation == VK_NULL_HANDLE)

+                {

+                    ++m_1stNullItemsBeginCount;

+                    --m_1stNullItemsMiddleCount;

+                }

+                m_2ndNullItemsCount = 0;

+                m_1stVectorIndex ^= 1;

+            }

+        }

+    }

+

+    VMA_HEAVY_ASSERT(Validate());

+}

+

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaBlockMetadata_Buddy

+

+VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(VmaAllocator hAllocator) :

+    VmaBlockMetadata(hAllocator),

+    m_Root(VMA_NULL),

+    m_AllocationCount(0),

+    m_FreeCount(1),

+    m_SumFreeSize(0)

+{

+    memset(m_FreeList, 0, sizeof(m_FreeList));

+}

+

+VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()

+{

+    DeleteNode(m_Root);

+}

+

+void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)

+{

+    VmaBlockMetadata::Init(size);

+

+    m_UsableSize = VmaPrevPow2(size);

+    m_SumFreeSize = m_UsableSize;

+

+    // Calculate m_LevelCount.

+    m_LevelCount = 1;

+    while(m_LevelCount < MAX_LEVELS &&

+        LevelToNodeSize(m_LevelCount) >= MIN_NODE_SIZE)

+    {

+        ++m_LevelCount;

+    }

+

+    Node* rootNode = vma_new(GetAllocationCallbacks(), Node)();

+    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;

+}

+

+VkDeviceSize VmaBlockMetadata_Buddy::GetUnusedRangeSizeMax() const

+{

+    for(uint32_t level = 0; level < m_LevelCount; ++level)

+    {

+        if(m_FreeList[level].front != VMA_NULL)

+        {

+            return LevelToNodeSize(level);

+        }

+    }

+    return 0;

+}

+

+void VmaBlockMetadata_Buddy::CalcAllocationStatInfo(VmaStatInfo& outInfo) const

+{

+    const VkDeviceSize unusableSize = GetUnusableSize();

+

+    outInfo.blockCount = 1;

+

+    outInfo.allocationCount = outInfo.unusedRangeCount = 0;

+    outInfo.usedBytes = outInfo.unusedBytes = 0;

+

+    outInfo.allocationSizeMax = outInfo.unusedRangeSizeMax = 0;

+    outInfo.allocationSizeMin = outInfo.unusedRangeSizeMin = UINT64_MAX;

+    outInfo.allocationSizeAvg = outInfo.unusedRangeSizeAvg = 0; // Unused.

+

+    CalcAllocationStatInfoNode(outInfo, m_Root, LevelToNodeSize(0));

+

+    if(unusableSize > 0)

+    {

+        ++outInfo.unusedRangeCount;

+        outInfo.unusedBytes += unusableSize;

+        outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusableSize);

+        outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusableSize);

+    }

+}

+

+void VmaBlockMetadata_Buddy::AddPoolStats(VmaPoolStats& inoutStats) const

+{

+    const VkDeviceSize unusableSize = GetUnusableSize();

+

+    inoutStats.size += GetSize();

+    inoutStats.unusedSize += m_SumFreeSize + unusableSize;

+    inoutStats.allocationCount += m_AllocationCount;

+    inoutStats.unusedRangeCount += m_FreeCount;

+    inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());

+

+    if(unusableSize > 0)

+    {

+        ++inoutStats.unusedRangeCount;

+        // Not updating inoutStats.unusedRangeSizeMax with unusableSize because this space is not available for allocations.

+    }

+}

+

+#if VMA_STATS_STRING_ENABLED

+

+void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json) const

+{

+    // TODO optimize

+    VmaStatInfo stat;

+    CalcAllocationStatInfo(stat);

+

+    PrintDetailedMap_Begin(

+        json,

+        stat.unusedBytes,

+        stat.allocationCount,

+        stat.unusedRangeCount);

+

+    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 // #if VMA_STATS_STRING_ENABLED

+

+bool VmaBlockMetadata_Buddy::CreateAllocationRequest(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VkDeviceSize bufferImageGranularity,

+    VkDeviceSize allocSize,

+    VkDeviceSize allocAlignment,

+    bool upperAddress,

+    VmaSuballocationType allocType,

+    bool canMakeOtherLost,

+    uint32_t strategy,

+    VmaAllocationRequest* pAllocationRequest)

+{

+    VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");

+

+    // 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, bufferImageGranularity);

+        allocSize = VMA_MAX(allocSize, bufferImageGranularity);

+    }

+

+    if(allocSize > m_UsableSize)

+    {

+        return false;

+    }

+

+    const uint32_t targetLevel = AllocSizeToLevel(allocSize);

+    for(uint32_t level = targetLevel + 1; 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->offset = freeNode->offset;

+                pAllocationRequest->sumFreeSize = LevelToNodeSize(level);

+                pAllocationRequest->sumItemSize = 0;

+                pAllocationRequest->itemsToMakeLostCount = 0;

+                pAllocationRequest->customData = (void*)(uintptr_t)level;

+                return true;

+            }

+        }

+    }

+

+    return false;

+}

+

+bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost(

+    uint32_t currentFrameIndex,

+    uint32_t frameInUseCount,

+    VmaAllocationRequest* pAllocationRequest)

+{

+    /*

+    Lost allocations are not supported in buddy allocator at the moment.

+    Support might be added in the future.

+    */

+    return pAllocationRequest->itemsToMakeLostCount == 0;

+}

+

+uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)

+{

+    /*

+    Lost allocations are not supported in buddy allocator at the moment.

+    Support might be added in the future.

+    */

+    return 0;

+}

+

+void VmaBlockMetadata_Buddy::Alloc(

+    const VmaAllocationRequest& request,

+    VmaSuballocationType type,

+    VkDeviceSize allocSize,

+    VmaAllocation hAllocation)

+{

+    VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);

+

+    const uint32_t targetLevel = AllocSizeToLevel(allocSize);

+    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);

+    while(currNode->offset != request.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 = vma_new(GetAllocationCallbacks(), Node)();

+        Node* rightChild = vma_new(GetAllocationCallbacks(), Node)();

+

+        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;

+        //m_SumFreeSize -= LevelToNodeSize(currLevel) % 2; // Useful only when level node sizes can be non power of 2.

+        ++currLevel;

+        currNode = m_FreeList[currLevel].front;

+

+        /*

+        We can be sure that currNode, as left child of node previously split,

+        also fullfills 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.alloc = hAllocation;

+

+    ++m_AllocationCount;

+    --m_FreeCount;

+    m_SumFreeSize -= allocSize;

+}

+

+void VmaBlockMetadata_Buddy::DeleteNode(Node* node)

+{

+    if(node->type == Node::TYPE_SPLIT)

+    {

+        DeleteNode(node->split.leftChild->buddy);

+        DeleteNode(node->split.leftChild);

+    }

+

+    vma_delete(GetAllocationCallbacks(), 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;

+        ctx.calculatedSumFreeSize += levelNodeSize - curr->allocation.alloc->GetSize();

+        VMA_VALIDATE(curr->allocation.alloc != VK_NULL_HANDLE);

+        break;

+    case Node::TYPE_SPLIT:

+        {

+            const uint32_t childrenLevel = level + 1;

+            const VkDeviceSize childrenLevelNodeSize = levelNodeSize / 2;

+            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 = nextLevelNodeSize;

+        nextLevelNodeSize = currLevelNodeSize >> 1;

+    }

+    return level;

+}

+

+void VmaBlockMetadata_Buddy::FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset)

+{

+    // Find node and level.

+    Node* node = m_Root;

+    VkDeviceSize nodeOffset = 0;

+    uint32_t level = 0;

+    VkDeviceSize levelNodeSize = LevelToNodeSize(0);

+    while(node->type == Node::TYPE_SPLIT)

+    {

+        const VkDeviceSize nextLevelSize = levelNodeSize >> 1;

+        if(offset < nodeOffset + nextLevelSize)

+        {

+            node = node->split.leftChild;

+        }

+        else

+        {

+            node = node->split.leftChild->buddy;

+            nodeOffset += nextLevelSize;

+        }

+        ++level;

+        levelNodeSize = nextLevelSize;

+    }

+

+    VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);

+    VMA_ASSERT(alloc == VK_NULL_HANDLE || node->allocation.alloc == alloc);

+

+    ++m_FreeCount;

+    --m_AllocationCount;

+    m_SumFreeSize += alloc->GetSize();

+

+    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;

+

+        vma_delete(GetAllocationCallbacks(), node->buddy);

+        vma_delete(GetAllocationCallbacks(), node);

+        parent->type = Node::TYPE_FREE;

+

+        node = parent;

+        --level;

+        //m_SumFreeSize += LevelToNodeSize(level) % 2; // Useful only when level node sizes can be non power of 2.

+        --m_FreeCount;

+    }

+

+    AddToFreeListFront(level, node);

+}

+

+void VmaBlockMetadata_Buddy::CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const

+{

+    switch(node->type)

+    {

+    case Node::TYPE_FREE:

+        ++outInfo.unusedRangeCount;

+        outInfo.unusedBytes += levelNodeSize;

+        outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, levelNodeSize);

+        outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, levelNodeSize);

+        break;

+    case Node::TYPE_ALLOCATION:

+        {

+            const VkDeviceSize allocSize = node->allocation.alloc->GetSize();

+            ++outInfo.allocationCount;

+            outInfo.usedBytes += allocSize;

+            outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, allocSize);

+            outInfo.allocationSizeMin = VMA_MAX(outInfo.allocationSizeMin, allocSize);

+

+            const VkDeviceSize unusedRangeSize = levelNodeSize - allocSize;

+            if(unusedRangeSize > 0)

+            {

+                ++outInfo.unusedRangeCount;

+                outInfo.unusedBytes += unusedRangeSize;

+                outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusedRangeSize);

+                outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, unusedRangeSize);

+            }

+        }

+        break;

+    case Node::TYPE_SPLIT:

+        {

+            const VkDeviceSize childrenNodeSize = levelNodeSize / 2;

+            const Node* const leftChild = node->split.leftChild;

+            CalcAllocationStatInfoNode(outInfo, leftChild, childrenNodeSize);

+            const Node* const rightChild = leftChild->buddy;

+            CalcAllocationStatInfoNode(outInfo, 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;

+    }

+}

+

+#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, node->allocation.alloc);

+            const VkDeviceSize allocSize = node->allocation.alloc->GetSize();

+            if(allocSize < levelNodeSize)

+            {

+                PrintDetailedMap_UnusedRange(json, node->offset + allocSize, levelNodeSize - allocSize);

+            }

+        }

+        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 // #if VMA_STATS_STRING_ENABLED

+

+

+////////////////////////////////////////////////////////////////////////////////

+// class VmaDeviceMemoryBlock

+

+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)

+{

+}

+

+void VmaDeviceMemoryBlock::Init(

+    VmaAllocator hAllocator,

+    VmaPool hParentPool,

+    uint32_t newMemoryTypeIndex,

+    VkDeviceMemory newMemory,

+    VkDeviceSize newSize,

+    uint32_t id,

+    uint32_t algorithm)

+{

+    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);

+        break;

+    case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:

+        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Buddy)(hAllocator);

+        break;

+    default:

+        VMA_ASSERT(0);

+        // Fall-through.

+    case 0:

+        m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);

+    }

+    m_pMetadata->Init(newSize);

+}

+

+void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)

+{

+    // 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;

+}

+

+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_Mutex, hAllocator->m_UseMutex);

+    if(m_MapCount != 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_Mutex, hAllocator->m_UseMutex);

+    if(m_MapCount >= count)

+    {

+        m_MapCount -= count;

+        if(m_MapCount == 0)

+        {

+            m_pMappedData = VMA_NULL;

+            (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);

+        }

+    }

+    else

+    {

+        VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");

+    }

+}

+

+VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)

+{

+    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);

+    VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);

+

+    void* pData;

+    VkResult res = Map(hAllocator, 1, &pData);

+    if(res != VK_SUCCESS)

+    {

+        return res;

+    }

+

+    VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);

+    VmaWriteMagicValue(pData, allocOffset + allocSize);

+

+    Unmap(hAllocator, 1);

+

+    return VK_SUCCESS;

+}

+

+VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)

+{

+    VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);

+    VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);

+

+    void* pData;

+    VkResult res = Map(hAllocator, 1, &pData);

+    if(res != VK_SUCCESS)

+    {

+        return res;

+    }

+

+    if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))

+    {

+        VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");

+    }

+    else 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_Mutex, 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_Mutex, hAllocator->m_UseMutex);

+    return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);

+}

+

+static void InitStatInfo(VmaStatInfo& outInfo)

+{

+    memset(&outInfo, 0, sizeof(outInfo));

+    outInfo.allocationSizeMin = UINT64_MAX;

+    outInfo.unusedRangeSizeMin = UINT64_MAX;

+}

+

+// Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.

+static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)

+{

+    inoutInfo.blockCount += srcInfo.blockCount;

+    inoutInfo.allocationCount += srcInfo.allocationCount;

+    inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;

+    inoutInfo.usedBytes += srcInfo.usedBytes;

+    inoutInfo.unusedBytes += srcInfo.unusedBytes;

+    inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);

+    inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);

+    inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);

+    inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);

+}

+

+static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)

+{

+    inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?

+        VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;

+    inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?

+        VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;

+}

+

+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.frameInUseCount,

+        createInfo.blockSize != 0, // explicitBlockSize

+        createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK), // algorithm

+    m_Id(0),

+    m_Name(VMA_NULL)

+{

+}

+

+VmaPool_T::~VmaPool_T()

+{

+}

+

+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;

+    }

+}

+

+#if VMA_STATS_STRING_ENABLED

+

+#endif // #if VMA_STATS_STRING_ENABLED

+

+VmaBlockVector::VmaBlockVector(

+    VmaAllocator hAllocator,

+    VmaPool hParentPool,

+    uint32_t memoryTypeIndex,

+    VkDeviceSize preferredBlockSize,

+    size_t minBlockCount,

+    size_t maxBlockCount,

+    VkDeviceSize bufferImageGranularity,

+    uint32_t frameInUseCount,

+    bool explicitBlockSize,

+    uint32_t algorithm) :

+    m_hAllocator(hAllocator),

+    m_hParentPool(hParentPool),

+    m_MemoryTypeIndex(memoryTypeIndex),

+    m_PreferredBlockSize(preferredBlockSize),

+    m_MinBlockCount(minBlockCount),

+    m_MaxBlockCount(maxBlockCount),

+    m_BufferImageGranularity(bufferImageGranularity),

+    m_FrameInUseCount(frameInUseCount),

+    m_ExplicitBlockSize(explicitBlockSize),

+    m_Algorithm(algorithm),

+    m_HasEmptyBlock(false),

+    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::GetPoolStats(VmaPoolStats* pStats)

+{

+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);

+

+    const size_t blockCount = m_Blocks.size();

+

+    pStats->size = 0;

+    pStats->unusedSize = 0;

+    pStats->allocationCount = 0;

+    pStats->unusedRangeCount = 0;

+    pStats->unusedRangeSizeMax = 0;

+    pStats->blockCount = blockCount;

+

+    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->AddPoolStats(*pStats);

+    }

+}

+

+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;

+}

+

+static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;

+

+VkResult VmaBlockVector::Allocate(

+    uint32_t currentFrameIndex,

+    VkDeviceSize size,

+    VkDeviceSize alignment,

+    const VmaAllocationCreateInfo& createInfo,

+    VmaSuballocationType suballocType,

+    size_t allocationCount,

+    VmaAllocation* pAllocations)

+{

+    size_t allocIndex;

+    VkResult res = VK_SUCCESS;

+

+    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(

+                currentFrameIndex,

+                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(

+    uint32_t currentFrameIndex,

+    VkDeviceSize size,

+    VkDeviceSize alignment,

+    const VmaAllocationCreateInfo& createInfo,

+    VmaSuballocationType suballocType,

+    VmaAllocation* pAllocation)

+{

+    const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;

+    bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;

+    const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;

+    const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;

+

+    VkDeviceSize freeMemory;

+    {

+        const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);

+        VmaBudget heapBudget = {};

+        m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);

+        freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;

+    }

+

+    const bool canFallbackToDedicated = !IsCustomPool();

+    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;

+

+    // If linearAlgorithm is used, canMakeOtherLost is available only when used as ring buffer.

+    // Which in turn is available only when maxBlockCount = 1.

+    if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT && m_MaxBlockCount > 1)

+    {

+        canMakeOtherLost = false;

+    }

+

+    // 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;

+    }

+

+    // Validate strategy.

+    switch(strategy)

+    {

+    case 0:

+        strategy = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT;

+        break;

+    case VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT:

+    case VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT:

+    case VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT:

+        break;

+    default:

+        return VK_ERROR_FEATURE_NOT_PRESENT;

+    }

+

+    // Early reject: requested allocation size is larger that maximum block size for this block vector.

+    if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)

+    {

+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+    }

+

+    /*

+    Under certain condition, this whole section can be skipped for optimization, so

+    we move on directly to trying to allocate with canMakeOtherLost. That's the case

+    e.g. for custom pools with linear algorithm.

+    */

+    if(!canMakeOtherLost || canCreateNewBlock)

+    {

+        // 1. Search existing allocations. Try to allocate without making other allocations lost.

+        VmaAllocationCreateFlags allocFlagsCopy = createInfo.flags;

+        allocFlagsCopy &= ~VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;

+

+        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,

+                    currentFrameIndex,

+                    size,

+                    alignment,

+                    allocFlagsCopy,

+                    createInfo.pUserData,

+                    suballocType,

+                    strategy,

+                    pAllocation);

+                if(res == VK_SUCCESS)

+                {

+                    VMA_DEBUG_LOG("    Returned from last block #%u", pCurrBlock->GetId());

+                    return VK_SUCCESS;

+                }

+            }

+        }

+        else

+        {

+            if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)

+            {

+                // 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,

+                        currentFrameIndex,

+                        size,

+                        alignment,

+                        allocFlagsCopy,

+                        createInfo.pUserData,

+                        suballocType,

+                        strategy,

+                        pAllocation);

+                    if(res == VK_SUCCESS)

+                    {

+                        VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());

+                        return VK_SUCCESS;

+                    }

+                }

+            }

+            else // WORST_FIT, FIRST_FIT

+            {

+                // 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,

+                        currentFrameIndex,

+                        size,

+                        alignment,

+                        allocFlagsCopy,

+                        createInfo.pUserData,

+                        suballocType,

+                        strategy,

+                        pAllocation);

+                    if(res == VK_SUCCESS)

+                    {

+                        VMA_DEBUG_LOG("    Returned from existing block #%u", pCurrBlock->GetId());

+                        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,

+                    currentFrameIndex,

+                    size,

+                    alignment,

+                    allocFlagsCopy,

+                    createInfo.pUserData,

+                    suballocType,

+                    strategy,

+                    pAllocation);

+                if(res == VK_SUCCESS)

+                {

+                    VMA_DEBUG_LOG("    Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);

+                    return VK_SUCCESS;

+                }

+                else

+                {

+                    // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.

+                    return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+                }

+            }

+        }

+    }

+

+    // 3. Try to allocate from existing blocks with making other allocations lost.

+    if(canMakeOtherLost)

+    {

+        uint32_t tryIndex = 0;

+        for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)

+        {

+            VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;

+            VmaAllocationRequest bestRequest = {};

+            VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;

+

+            // 1. Search existing allocations.

+            if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)

+            {

+                // 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);

+                    VmaAllocationRequest currRequest = {};

+                    if(pCurrBlock->m_pMetadata->CreateAllocationRequest(

+                        currentFrameIndex,

+                        m_FrameInUseCount,

+                        m_BufferImageGranularity,

+                        size,

+                        alignment,

+                        (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,

+                        suballocType,

+                        canMakeOtherLost,

+                        strategy,

+                        &currRequest))

+                    {

+                        const VkDeviceSize currRequestCost = currRequest.CalcCost();

+                        if(pBestRequestBlock == VMA_NULL ||

+                            currRequestCost < bestRequestCost)

+                        {

+                            pBestRequestBlock = pCurrBlock;

+                            bestRequest = currRequest;

+                            bestRequestCost = currRequestCost;

+

+                            if(bestRequestCost == 0)

+                            {

+                                break;

+                            }

+                        }

+                    }

+                }

+            }

+            else // WORST_FIT, FIRST_FIT

+            {

+                // 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);

+                    VmaAllocationRequest currRequest = {};

+                    if(pCurrBlock->m_pMetadata->CreateAllocationRequest(

+                        currentFrameIndex,

+                        m_FrameInUseCount,

+                        m_BufferImageGranularity,

+                        size,

+                        alignment,

+                        (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,

+                        suballocType,

+                        canMakeOtherLost,

+                        strategy,

+                        &currRequest))

+                    {

+                        const VkDeviceSize currRequestCost = currRequest.CalcCost();

+                        if(pBestRequestBlock == VMA_NULL ||

+                            currRequestCost < bestRequestCost ||

+                            strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)

+                        {

+                            pBestRequestBlock = pCurrBlock;

+                            bestRequest = currRequest;

+                            bestRequestCost = currRequestCost;

+

+                            if(bestRequestCost == 0 ||

+                                strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)

+                            {

+                                break;

+                            }

+                        }

+                    }

+                }

+            }

+

+            if(pBestRequestBlock != VMA_NULL)

+            {

+                if(mapped)

+                {

+                    VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);

+                    if(res != VK_SUCCESS)

+                    {

+                        return res;

+                    }

+                }

+

+                if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(

+                    currentFrameIndex,

+                    m_FrameInUseCount,

+                    &bestRequest))

+                {

+                    // Allocate from this pBlock.

+                    *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate(currentFrameIndex, isUserDataString);

+                    pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, *pAllocation);

+                    UpdateHasEmptyBlock();

+                    (*pAllocation)->InitBlockAllocation(

+                        pBestRequestBlock,

+                        bestRequest.offset,

+                        alignment,

+                        size,

+                        m_MemoryTypeIndex,

+                        suballocType,

+                        mapped,

+                        (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);

+                    VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());

+                    VMA_DEBUG_LOG("    Returned from existing block");

+                    (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);

+                    m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);

+                    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)

+                    {

+                        m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);

+                    }

+                    if(IsCorruptionDetectionEnabled())

+                    {

+                        VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);

+                        VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");

+                    }

+                    return VK_SUCCESS;

+                }

+                // else: Some allocations must have been touched while we are here. Next try.

+            }

+            else

+            {

+                // Could not find place in any of the blocks - break outer loop.

+                break;

+            }

+        }

+        /* Maximum number of tries exceeded - a very unlike event when many other

+        threads are simultaneously touching allocations making it impossible to make

+        lost at the same time as we try to allocate. */

+        if(tryIndex == VMA_ALLOCATION_TRY_COUNT)

+        {

+            return VK_ERROR_TOO_MANY_OBJECTS;

+        }

+    }

+

+    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->GetBudget(&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->ValidateMagicValueAroundAllocation(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);

+        }

+

+        pBlock->m_pMetadata->Free(hAllocation);

+        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 has empty block. We don't want to have two, so delete this one.

+            if((m_HasEmptyBlock || budgetExceeded) && canDeleteBlock)

+            {

+                pBlockToDelete = pBlock;

+                Remove(pBlock);

+            }

+            // else: We now have an empty block - leave it.

+        }

+        // pBlock didn't become empty, but we have another empty block - find and free that one.

+        // (This is optional, heuristics.)

+        else if(m_HasEmptyBlock && canDeleteBlock)

+        {

+            VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();

+            if(pLastBlock->m_pMetadata->IsEmpty())

+            {

+                pBlockToDelete = pLastBlock;

+                m_Blocks.pop_back();

+            }

+        }

+

+        UpdateHasEmptyBlock();

+        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");

+        pBlockToDelete->Destroy(m_hAllocator);

+        vma_delete(m_hAllocator, pBlockToDelete);

+    }

+}

+

+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_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;

+            }

+        }

+    }

+}

+

+VkResult VmaBlockVector::AllocateFromBlock(

+    VmaDeviceMemoryBlock* pBlock,

+    uint32_t currentFrameIndex,

+    VkDeviceSize size,

+    VkDeviceSize alignment,

+    VmaAllocationCreateFlags allocFlags,

+    void* pUserData,

+    VmaSuballocationType suballocType,

+    uint32_t strategy,

+    VmaAllocation* pAllocation)

+{

+    VMA_ASSERT((allocFlags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) == 0);

+    const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;

+    const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;

+    const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;

+

+    VmaAllocationRequest currRequest = {};

+    if(pBlock->m_pMetadata->CreateAllocationRequest(

+        currentFrameIndex,

+        m_FrameInUseCount,

+        m_BufferImageGranularity,

+        size,

+        alignment,

+        isUpperAddress,

+        suballocType,

+        false, // canMakeOtherLost

+        strategy,

+        &currRequest))

+    {

+        // Allocate from pCurrBlock.

+        VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);

+

+        if(mapped)

+        {

+            VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);

+            if(res != VK_SUCCESS)

+            {

+                return res;

+            }

+        }

+

+        *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate(currentFrameIndex, isUserDataString);

+        pBlock->m_pMetadata->Alloc(currRequest, suballocType, size, *pAllocation);

+        UpdateHasEmptyBlock();

+        (*pAllocation)->InitBlockAllocation(

+            pBlock,

+            currRequest.offset,

+            alignment,

+            size,

+            m_MemoryTypeIndex,

+            suballocType,

+            mapped,

+            (allocFlags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);

+        VMA_HEAVY_ASSERT(pBlock->Validate());

+        (*pAllocation)->SetUserData(m_hAllocator, pUserData);

+        m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);

+        if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)

+        {

+            m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);

+        }

+        if(IsCorruptionDetectionEnabled())

+        {

+            VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);

+            VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");

+        }

+        return VK_SUCCESS;

+    }

+    return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+}

+

+VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)

+{

+    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };

+    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 // #if VMA_BUFFER_DEVICE_ADDRESS

+

+    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_Blocks.push_back(pBlock);

+    if(pNewBlockIndex != VMA_NULL)

+    {

+        *pNewBlockIndex = m_Blocks.size() - 1;

+    }

+

+    return VK_SUCCESS;

+}

+

+void VmaBlockVector::ApplyDefragmentationMovesCpu(

+    class VmaBlockVectorDefragmentationContext* pDefragCtx,

+    const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves)

+{

+    const size_t blockCount = m_Blocks.size();

+    const bool isNonCoherent = m_hAllocator->IsMemoryTypeNonCoherent(m_MemoryTypeIndex);

+

+    enum BLOCK_FLAG

+    {

+        BLOCK_FLAG_USED = 0x00000001,

+        BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION = 0x00000002,

+    };

+

+    struct BlockInfo

+    {

+        uint32_t flags;

+        void* pMappedData;

+    };

+    VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> >

+        blockInfo(blockCount, BlockInfo(), VmaStlAllocator<BlockInfo>(m_hAllocator->GetAllocationCallbacks()));

+    memset(blockInfo.data(), 0, blockCount * sizeof(BlockInfo));

+

+    // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.

+    const size_t moveCount = moves.size();

+    for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)

+    {

+        const VmaDefragmentationMove& move = moves[moveIndex];

+        blockInfo[move.srcBlockIndex].flags |= BLOCK_FLAG_USED;

+        blockInfo[move.dstBlockIndex].flags |= BLOCK_FLAG_USED;

+    }

+

+    VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);

+

+    // Go over all blocks. Get mapped pointer or map if necessary.

+    for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)

+    {

+        BlockInfo& currBlockInfo = blockInfo[blockIndex];

+        VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];

+        if((currBlockInfo.flags & BLOCK_FLAG_USED) != 0)

+        {

+            currBlockInfo.pMappedData = pBlock->GetMappedData();

+            // It is not originally mapped - map it.

+            if(currBlockInfo.pMappedData == VMA_NULL)

+            {

+                pDefragCtx->res = pBlock->Map(m_hAllocator, 1, &currBlockInfo.pMappedData);

+                if(pDefragCtx->res == VK_SUCCESS)

+                {

+                    currBlockInfo.flags |= BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION;

+                }

+            }

+        }

+    }

+

+    // Go over all moves. Do actual data transfer.

+    if(pDefragCtx->res == VK_SUCCESS)

+    {

+        const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;

+        VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };

+

+        for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)

+        {

+            const VmaDefragmentationMove& move = moves[moveIndex];

+

+            const BlockInfo& srcBlockInfo = blockInfo[move.srcBlockIndex];

+            const BlockInfo& dstBlockInfo = blockInfo[move.dstBlockIndex];

+

+            VMA_ASSERT(srcBlockInfo.pMappedData && dstBlockInfo.pMappedData);

+

+            // Invalidate source.

+            if(isNonCoherent)

+            {

+                VmaDeviceMemoryBlock* const pSrcBlock = m_Blocks[move.srcBlockIndex];

+                memRange.memory = pSrcBlock->GetDeviceMemory();

+                memRange.offset = VmaAlignDown(move.srcOffset, nonCoherentAtomSize);

+                memRange.size = VMA_MIN(

+                    VmaAlignUp(move.size + (move.srcOffset - memRange.offset), nonCoherentAtomSize),

+                    pSrcBlock->m_pMetadata->GetSize() - memRange.offset);

+                (*m_hAllocator->GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);

+            }

+

+            // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.

+            memmove(

+                reinterpret_cast<char*>(dstBlockInfo.pMappedData) + move.dstOffset,

+                reinterpret_cast<char*>(srcBlockInfo.pMappedData) + move.srcOffset,

+                static_cast<size_t>(move.size));

+

+            if(IsCorruptionDetectionEnabled())

+            {

+                VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset - VMA_DEBUG_MARGIN);

+                VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset + move.size);

+            }

+

+            // Flush destination.

+            if(isNonCoherent)

+            {

+                VmaDeviceMemoryBlock* const pDstBlock = m_Blocks[move.dstBlockIndex];

+                memRange.memory = pDstBlock->GetDeviceMemory();

+                memRange.offset = VmaAlignDown(move.dstOffset, nonCoherentAtomSize);

+                memRange.size = VMA_MIN(

+                    VmaAlignUp(move.size + (move.dstOffset - memRange.offset), nonCoherentAtomSize),

+                    pDstBlock->m_pMetadata->GetSize() - memRange.offset);

+                (*m_hAllocator->GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);

+            }

+        }

+    }

+

+    // Go over all blocks in reverse order. Unmap those that were mapped just for defragmentation.

+    // Regardless of pCtx->res == VK_SUCCESS.

+    for(size_t blockIndex = blockCount; blockIndex--; )

+    {

+        const BlockInfo& currBlockInfo = blockInfo[blockIndex];

+        if((currBlockInfo.flags & BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION) != 0)

+        {

+            VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];

+            pBlock->Unmap(m_hAllocator, 1);

+        }

+    }

+}

+

+void VmaBlockVector::ApplyDefragmentationMovesGpu(

+    class VmaBlockVectorDefragmentationContext* pDefragCtx,

+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+    VkCommandBuffer commandBuffer)

+{

+    const size_t blockCount = m_Blocks.size();

+

+    pDefragCtx->blockContexts.resize(blockCount);

+    memset(pDefragCtx->blockContexts.data(), 0, blockCount * sizeof(VmaBlockDefragmentationContext));

+

+    // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.

+    const size_t moveCount = moves.size();

+    for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)

+    {

+        const VmaDefragmentationMove& move = moves[moveIndex];

+

+        //if(move.type == VMA_ALLOCATION_TYPE_UNKNOWN)

+        {

+            // Old school move still require us to map the whole block

+            pDefragCtx->blockContexts[move.srcBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;

+            pDefragCtx->blockContexts[move.dstBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;

+        }

+    }

+

+    VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);

+

+    // Go over all blocks. Create and bind buffer for whole block if necessary.

+    {

+        VkBufferCreateInfo bufCreateInfo;

+        VmaFillGpuDefragmentationBufferCreateInfo(bufCreateInfo);

+

+        for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)

+        {

+            VmaBlockDefragmentationContext& currBlockCtx = pDefragCtx->blockContexts[blockIndex];

+            VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];

+            if((currBlockCtx.flags & VmaBlockDefragmentationContext::BLOCK_FLAG_USED) != 0)

+            {

+                bufCreateInfo.size = pBlock->m_pMetadata->GetSize();

+                pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkCreateBuffer)(

+                    m_hAllocator->m_hDevice, &bufCreateInfo, m_hAllocator->GetAllocationCallbacks(), &currBlockCtx.hBuffer);

+                if(pDefragCtx->res == VK_SUCCESS)

+                {

+                    pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkBindBufferMemory)(

+                        m_hAllocator->m_hDevice, currBlockCtx.hBuffer, pBlock->GetDeviceMemory(), 0);

+                }

+            }

+        }

+    }

+

+    // Go over all moves. Post data transfer commands to command buffer.

+    if(pDefragCtx->res == VK_SUCCESS)

+    {

+        for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)

+        {

+            const VmaDefragmentationMove& move = moves[moveIndex];

+

+            const VmaBlockDefragmentationContext& srcBlockCtx = pDefragCtx->blockContexts[move.srcBlockIndex];

+            const VmaBlockDefragmentationContext& dstBlockCtx = pDefragCtx->blockContexts[move.dstBlockIndex];

+

+            VMA_ASSERT(srcBlockCtx.hBuffer && dstBlockCtx.hBuffer);

+

+            VkBufferCopy region = {

+                move.srcOffset,

+                move.dstOffset,

+                move.size };

+            (*m_hAllocator->GetVulkanFunctions().vkCmdCopyBuffer)(

+                commandBuffer, srcBlockCtx.hBuffer, dstBlockCtx.hBuffer, 1, &region);

+        }

+    }

+

+    // Save buffers to defrag context for later destruction.

+    if(pDefragCtx->res == VK_SUCCESS && moveCount > 0)

+    {

+        pDefragCtx->res = VK_NOT_READY;

+    }

+}

+

+void VmaBlockVector::FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats)

+{

+    for(size_t blockIndex = m_Blocks.size(); blockIndex--; )

+    {

+        VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];

+        if(pBlock->m_pMetadata->IsEmpty())

+        {

+            if(m_Blocks.size() > m_MinBlockCount)

+            {

+                if(pDefragmentationStats != VMA_NULL)

+                {

+                    ++pDefragmentationStats->deviceMemoryBlocksFreed;

+                    pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();

+                }

+

+                VmaVectorRemove(m_Blocks, blockIndex);

+                pBlock->Destroy(m_hAllocator);

+                vma_delete(m_hAllocator, pBlock);

+            }

+            else

+            {

+                break;

+            }

+        }

+    }

+    UpdateHasEmptyBlock();

+}

+

+void VmaBlockVector::UpdateHasEmptyBlock()

+{

+    m_HasEmptyBlock = false;

+    for(size_t index = 0, count = m_Blocks.size(); index < count; ++index)

+    {

+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[index];

+        if(pBlock->m_pMetadata->IsEmpty())

+        {

+            m_HasEmptyBlock = true;

+            break;

+        }

+    }

+}

+

+#if VMA_STATS_STRING_ENABLED

+

+void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)

+{

+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);

+

+    json.BeginObject();

+

+    if(IsCustomPool())

+    {

+        const char* poolName = m_hParentPool->GetName();

+        if(poolName != VMA_NULL && poolName[0] != '\0')

+        {

+            json.WriteString("Name");

+            json.WriteString(poolName);

+        }

+

+        json.WriteString("MemoryTypeIndex");

+        json.WriteNumber(m_MemoryTypeIndex);

+

+        json.WriteString("BlockSize");

+        json.WriteNumber(m_PreferredBlockSize);

+

+        json.WriteString("BlockCount");

+        json.BeginObject(true);

+        if(m_MinBlockCount > 0)

+        {

+            json.WriteString("Min");

+            json.WriteNumber((uint64_t)m_MinBlockCount);

+        }

+        if(m_MaxBlockCount < SIZE_MAX)

+        {

+            json.WriteString("Max");

+            json.WriteNumber((uint64_t)m_MaxBlockCount);

+        }

+        json.WriteString("Cur");

+        json.WriteNumber((uint64_t)m_Blocks.size());

+        json.EndObject();

+

+        if(m_FrameInUseCount > 0)

+        {

+            json.WriteString("FrameInUseCount");

+            json.WriteNumber(m_FrameInUseCount);

+        }

+

+        if(m_Algorithm != 0)

+        {

+            json.WriteString("Algorithm");

+            json.WriteString(VmaAlgorithmToStr(m_Algorithm));

+        }

+    }

+    else

+    {

+        json.WriteString("PreferredBlockSize");

+        json.WriteNumber(m_PreferredBlockSize);

+    }

+

+    json.WriteString("Blocks");

+    json.BeginObject();

+    for(size_t i = 0; i < m_Blocks.size(); ++i)

+    {

+        json.BeginString();

+        json.ContinueString(m_Blocks[i]->GetId());

+        json.EndString();

+

+        m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);

+    }

+    json.EndObject();

+

+    json.EndObject();

+}

+

+#endif // #if VMA_STATS_STRING_ENABLED

+

+void VmaBlockVector::Defragment(

+    class VmaBlockVectorDefragmentationContext* pCtx,

+    VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags,

+    VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,

+    VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,

+    VkCommandBuffer commandBuffer)

+{

+    pCtx->res = VK_SUCCESS;

+

+    const VkMemoryPropertyFlags memPropFlags =

+        m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags;

+    const bool isHostVisible = (memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;

+

+    const bool canDefragmentOnCpu = maxCpuBytesToMove > 0 && maxCpuAllocationsToMove > 0 &&

+        isHostVisible;

+    const bool canDefragmentOnGpu = maxGpuBytesToMove > 0 && maxGpuAllocationsToMove > 0 &&

+        !IsCorruptionDetectionEnabled() &&

+        ((1u << m_MemoryTypeIndex) & m_hAllocator->GetGpuDefragmentationMemoryTypeBits()) != 0;

+

+    // There are options to defragment this memory type.

+    if(canDefragmentOnCpu || canDefragmentOnGpu)

+    {

+        bool defragmentOnGpu;

+        // There is only one option to defragment this memory type.

+        if(canDefragmentOnGpu != canDefragmentOnCpu)

+        {

+            defragmentOnGpu = canDefragmentOnGpu;

+        }

+        // Both options are available: Heuristics to choose the best one.

+        else

+        {

+            defragmentOnGpu = (memPropFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0 ||

+                m_hAllocator->IsIntegratedGpu();

+        }

+

+        bool overlappingMoveSupported = !defragmentOnGpu;

+

+        if(m_hAllocator->m_UseMutex)

+        {

+            if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL)

+            {

+                if(!m_Mutex.TryLockWrite())

+                {

+                    pCtx->res = VK_ERROR_INITIALIZATION_FAILED;

+                    return;

+                }

+            }

+            else

+            {

+                m_Mutex.LockWrite();

+                pCtx->mutexLocked = true;

+            }

+        }

+

+        pCtx->Begin(overlappingMoveSupported, flags);

+

+        // Defragment.

+

+        const VkDeviceSize maxBytesToMove = defragmentOnGpu ? maxGpuBytesToMove : maxCpuBytesToMove;

+        const uint32_t maxAllocationsToMove = defragmentOnGpu ? maxGpuAllocationsToMove : maxCpuAllocationsToMove;

+        pCtx->res = pCtx->GetAlgorithm()->Defragment(pCtx->defragmentationMoves, maxBytesToMove, maxAllocationsToMove, flags);

+

+        // Accumulate statistics.

+        if(pStats != VMA_NULL)

+        {

+            const VkDeviceSize bytesMoved = pCtx->GetAlgorithm()->GetBytesMoved();

+            const uint32_t allocationsMoved = pCtx->GetAlgorithm()->GetAllocationsMoved();

+            pStats->bytesMoved += bytesMoved;

+            pStats->allocationsMoved += allocationsMoved;

+            VMA_ASSERT(bytesMoved <= maxBytesToMove);

+            VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);

+            if(defragmentOnGpu)

+            {

+                maxGpuBytesToMove -= bytesMoved;

+                maxGpuAllocationsToMove -= allocationsMoved;

+            }

+            else

+            {

+                maxCpuBytesToMove -= bytesMoved;

+                maxCpuAllocationsToMove -= allocationsMoved;

+            }

+        }

+

+        if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL)

+        {

+            if(m_hAllocator->m_UseMutex)

+                m_Mutex.UnlockWrite();

+

+            if(pCtx->res >= VK_SUCCESS && !pCtx->defragmentationMoves.empty())

+                pCtx->res = VK_NOT_READY;

+

+            return;

+        }

+

+        if(pCtx->res >= VK_SUCCESS)

+        {

+            if(defragmentOnGpu)

+            {

+                ApplyDefragmentationMovesGpu(pCtx, pCtx->defragmentationMoves, commandBuffer);

+            }

+            else

+            {

+                ApplyDefragmentationMovesCpu(pCtx, pCtx->defragmentationMoves);

+            }

+        }

+    }

+}

+

+void VmaBlockVector::DefragmentationEnd(

+    class VmaBlockVectorDefragmentationContext* pCtx,

+    uint32_t flags,

+    VmaDefragmentationStats* pStats)

+{

+    if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL && m_hAllocator->m_UseMutex)

+    {

+        VMA_ASSERT(pCtx->mutexLocked == false);

+

+        // Incremental defragmentation doesn't hold the lock, so when we enter here we don't actually have any

+        // lock protecting us. Since we mutate state here, we have to take the lock out now

+        m_Mutex.LockWrite();

+        pCtx->mutexLocked = true;

+    }

+

+    // If the mutex isn't locked we didn't do any work and there is nothing to delete.

+    if(pCtx->mutexLocked || !m_hAllocator->m_UseMutex)

+    {

+        // Destroy buffers.

+        for(size_t blockIndex = pCtx->blockContexts.size(); blockIndex--;)

+        {

+            VmaBlockDefragmentationContext &blockCtx = pCtx->blockContexts[blockIndex];

+            if(blockCtx.hBuffer)

+            {

+                (*m_hAllocator->GetVulkanFunctions().vkDestroyBuffer)(m_hAllocator->m_hDevice, blockCtx.hBuffer, m_hAllocator->GetAllocationCallbacks());

+            }

+        }

+

+        if(pCtx->res >= VK_SUCCESS)

+        {

+            FreeEmptyBlocks(pStats);

+        }

+    }

+

+    if(pCtx->mutexLocked)

+    {

+        VMA_ASSERT(m_hAllocator->m_UseMutex);

+        m_Mutex.UnlockWrite();

+    }

+}

+

+uint32_t VmaBlockVector::ProcessDefragmentations(

+    class VmaBlockVectorDefragmentationContext *pCtx,

+    VmaDefragmentationPassMoveInfo* pMove, uint32_t maxMoves)

+{

+    VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);

+

+    const uint32_t moveCount = VMA_MIN(uint32_t(pCtx->defragmentationMoves.size()) - pCtx->defragmentationMovesProcessed, maxMoves);

+

+    for(uint32_t i = 0; i < moveCount; ++ i)

+    {

+        VmaDefragmentationMove& move = pCtx->defragmentationMoves[pCtx->defragmentationMovesProcessed + i];

+

+        pMove->allocation = move.hAllocation;

+        pMove->memory = move.pDstBlock->GetDeviceMemory();

+        pMove->offset = move.dstOffset;

+

+        ++ pMove;

+    }

+

+    pCtx->defragmentationMovesProcessed += moveCount;

+

+    return moveCount;

+}

+

+void VmaBlockVector::CommitDefragmentations(

+    class VmaBlockVectorDefragmentationContext *pCtx,

+    VmaDefragmentationStats* pStats)

+{

+    VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);

+

+    for(uint32_t i = pCtx->defragmentationMovesCommitted; i < pCtx->defragmentationMovesProcessed; ++ i)

+    {

+        const VmaDefragmentationMove &move = pCtx->defragmentationMoves[i];

+

+        move.pSrcBlock->m_pMetadata->FreeAtOffset(move.srcOffset);

+        move.hAllocation->ChangeBlockAllocation(m_hAllocator, move.pDstBlock, move.dstOffset);

+    }

+

+    pCtx->defragmentationMovesCommitted = pCtx->defragmentationMovesProcessed;

+    FreeEmptyBlocks(pStats);

+}

+

+size_t VmaBlockVector::CalcAllocationCount() const

+{

+    size_t result = 0;

+    for(size_t i = 0; i < m_Blocks.size(); ++i)

+    {

+        result += m_Blocks[i]->m_pMetadata->GetAllocationCount();

+    }

+    return result;

+}

+

+bool VmaBlockVector::IsBufferImageGranularityConflictPossible() const

+{

+    if(m_BufferImageGranularity == 1)

+    {

+        return false;

+    }

+    VmaSuballocationType lastSuballocType = VMA_SUBALLOCATION_TYPE_FREE;

+    for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)

+    {

+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[i];

+        VMA_ASSERT(m_Algorithm == 0);

+        VmaBlockMetadata_Generic* const pMetadata = (VmaBlockMetadata_Generic*)pBlock->m_pMetadata;

+        if(pMetadata->IsBufferImageGranularityConflictPossible(m_BufferImageGranularity, lastSuballocType))

+        {

+            return true;

+        }

+    }

+    return false;

+}

+

+void VmaBlockVector::MakePoolAllocationsLost(

+    uint32_t currentFrameIndex,

+    size_t* pLostAllocationCount)

+{

+    VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);

+    size_t lostAllocationCount = 0;

+    for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)

+    {

+        VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];

+        VMA_ASSERT(pBlock);

+        lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);

+    }

+    if(pLostAllocationCount != VMA_NULL)

+    {

+        *pLostAllocationCount = lostAllocationCount;

+    }

+}

+

+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;

+}

+

+void VmaBlockVector::AddStats(VmaStats* pStats)

+{

+    const uint32_t memTypeIndex = m_MemoryTypeIndex;

+    const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);

+

+    VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);

+

+    for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)

+    {

+        const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];

+        VMA_ASSERT(pBlock);

+        VMA_HEAVY_ASSERT(pBlock->Validate());

+        VmaStatInfo allocationStatInfo;

+        pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);

+        VmaAddStatInfo(pStats->total, allocationStatInfo);

+        VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);

+        VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);

+    }

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaDefragmentationAlgorithm_Generic members definition

+

+VmaDefragmentationAlgorithm_Generic::VmaDefragmentationAlgorithm_Generic(

+    VmaAllocator hAllocator,

+    VmaBlockVector* pBlockVector,

+    uint32_t currentFrameIndex,

+    bool overlappingMoveSupported) :

+    VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),

+    m_AllocationCount(0),

+    m_AllAllocations(false),

+    m_BytesMoved(0),

+    m_AllocationsMoved(0),

+    m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))

+{

+    // Create block info for each block.

+    const size_t blockCount = m_pBlockVector->m_Blocks.size();

+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)

+    {

+        BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());

+        pBlockInfo->m_OriginalBlockIndex = blockIndex;

+        pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];

+        m_Blocks.push_back(pBlockInfo);

+    }

+

+    // Sort them by m_pBlock pointer value.

+    VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());

+}

+

+VmaDefragmentationAlgorithm_Generic::~VmaDefragmentationAlgorithm_Generic()

+{

+    for(size_t i = m_Blocks.size(); i--; )

+    {

+        vma_delete(m_hAllocator, m_Blocks[i]);

+    }

+}

+

+void VmaDefragmentationAlgorithm_Generic::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)

+{

+    // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.

+    if(hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)

+    {

+        VmaDeviceMemoryBlock* pBlock = hAlloc->GetBlock();

+        BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());

+        if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)

+        {

+            AllocationInfo allocInfo = AllocationInfo(hAlloc, pChanged);

+            (*it)->m_Allocations.push_back(allocInfo);

+        }

+        else

+        {

+            VMA_ASSERT(0);

+        }

+

+        ++m_AllocationCount;

+    }

+}

+

+VkResult VmaDefragmentationAlgorithm_Generic::DefragmentRound(

+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+    VkDeviceSize maxBytesToMove,

+    uint32_t maxAllocationsToMove,

+    bool freeOldAllocations)

+{

+    if(m_Blocks.empty())

+    {

+        return VK_SUCCESS;

+    }

+

+    // This is a choice based on research.

+    // Option 1:

+    uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT;

+    // Option 2:

+    //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT;

+    // Option 3:

+    //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT;

+

+    size_t srcBlockMinIndex = 0;

+    // When FAST_ALGORITHM, move allocations from only last out of blocks that contain non-movable allocations.

+    /*

+    if(m_AlgorithmFlags & VMA_DEFRAGMENTATION_FAST_ALGORITHM_BIT)

+    {

+        const size_t blocksWithNonMovableCount = CalcBlocksWithNonMovableCount();

+        if(blocksWithNonMovableCount > 0)

+        {

+            srcBlockMinIndex = blocksWithNonMovableCount - 1;

+        }

+    }

+    */

+

+    size_t srcBlockIndex = m_Blocks.size() - 1;

+    size_t srcAllocIndex = SIZE_MAX;

+    for(;;)

+    {

+        // 1. Find next allocation to move.

+        // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".

+        // 1.2. Then start from last to first m_Allocations.

+        while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())

+        {

+            if(m_Blocks[srcBlockIndex]->m_Allocations.empty())

+            {

+                // Finished: no more allocations to process.

+                if(srcBlockIndex == srcBlockMinIndex)

+                {

+                    return VK_SUCCESS;

+                }

+                else

+                {

+                    --srcBlockIndex;

+                    srcAllocIndex = SIZE_MAX;

+                }

+            }

+            else

+            {

+                srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;

+            }

+        }

+

+        BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];

+        AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];

+

+        const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();

+        const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();

+        const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();

+        const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();

+

+        // 2. Try to find new place for this allocation in preceding or current block.

+        for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)

+        {

+            BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];

+            VmaAllocationRequest dstAllocRequest;

+            if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(

+                m_CurrentFrameIndex,

+                m_pBlockVector->GetFrameInUseCount(),

+                m_pBlockVector->GetBufferImageGranularity(),

+                size,

+                alignment,

+                false, // upperAddress

+                suballocType,

+                false, // canMakeOtherLost

+                strategy,

+                &dstAllocRequest) &&

+            MoveMakesSense(

+                dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))

+            {

+                VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);

+

+                // Reached limit on number of allocations or bytes to move.

+                if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||

+                    (m_BytesMoved + size > maxBytesToMove))

+                {

+                    return VK_SUCCESS;

+                }

+

+                VmaDefragmentationMove move = {};

+                move.srcBlockIndex = pSrcBlockInfo->m_OriginalBlockIndex;

+                move.dstBlockIndex = pDstBlockInfo->m_OriginalBlockIndex;

+                move.srcOffset = srcOffset;

+                move.dstOffset = dstAllocRequest.offset;

+                move.size = size;

+                move.hAllocation = allocInfo.m_hAllocation;

+                move.pSrcBlock = pSrcBlockInfo->m_pBlock;

+                move.pDstBlock = pDstBlockInfo->m_pBlock;

+

+                moves.push_back(move);

+

+                pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(

+                    dstAllocRequest,

+                    suballocType,

+                    size,

+                    allocInfo.m_hAllocation);

+

+                if(freeOldAllocations)

+                {

+                    pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);

+                    allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);

+                }

+

+                if(allocInfo.m_pChanged != VMA_NULL)

+                {

+                    *allocInfo.m_pChanged = VK_TRUE;

+                }

+

+                ++m_AllocationsMoved;

+                m_BytesMoved += size;

+

+                VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);

+

+                break;

+            }

+        }

+

+        // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.

+

+        if(srcAllocIndex > 0)

+        {

+            --srcAllocIndex;

+        }

+        else

+        {

+            if(srcBlockIndex > 0)

+            {

+                --srcBlockIndex;

+                srcAllocIndex = SIZE_MAX;

+            }

+            else

+            {

+                return VK_SUCCESS;

+            }

+        }

+    }

+}

+

+size_t VmaDefragmentationAlgorithm_Generic::CalcBlocksWithNonMovableCount() const

+{

+    size_t result = 0;

+    for(size_t i = 0; i < m_Blocks.size(); ++i)

+    {

+        if(m_Blocks[i]->m_HasNonMovableAllocations)

+        {

+            ++result;

+        }

+    }

+    return result;

+}

+

+VkResult VmaDefragmentationAlgorithm_Generic::Defragment(

+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+    VkDeviceSize maxBytesToMove,

+    uint32_t maxAllocationsToMove,

+    VmaDefragmentationFlags flags)

+{

+    if(!m_AllAllocations && m_AllocationCount == 0)

+    {

+        return VK_SUCCESS;

+    }

+

+    const size_t blockCount = m_Blocks.size();

+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)

+    {

+        BlockInfo* pBlockInfo = m_Blocks[blockIndex];

+

+        if(m_AllAllocations)

+        {

+            VmaBlockMetadata_Generic* pMetadata = (VmaBlockMetadata_Generic*)pBlockInfo->m_pBlock->m_pMetadata;

+            for(VmaSuballocationList::const_iterator it = pMetadata->m_Suballocations.begin();

+                it != pMetadata->m_Suballocations.end();

+                ++it)

+            {

+                if(it->type != VMA_SUBALLOCATION_TYPE_FREE)

+                {

+                    AllocationInfo allocInfo = AllocationInfo(it->hAllocation, VMA_NULL);

+                    pBlockInfo->m_Allocations.push_back(allocInfo);

+                }

+            }

+        }

+

+        pBlockInfo->CalcHasNonMovableAllocations();

+

+        // This is a choice based on research.

+        // Option 1:

+        pBlockInfo->SortAllocationsByOffsetDescending();

+        // Option 2:

+        //pBlockInfo->SortAllocationsBySizeDescending();

+    }

+

+    // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.

+    VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());

+

+    // This is a choice based on research.

+    const uint32_t roundCount = 2;

+

+    // Execute defragmentation rounds (the main part).

+    VkResult result = VK_SUCCESS;

+    for(uint32_t round = 0; (round < roundCount) && (result == VK_SUCCESS); ++round)

+    {

+        result = DefragmentRound(moves, maxBytesToMove, maxAllocationsToMove, !(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL));

+    }

+

+    return result;

+}

+

+bool VmaDefragmentationAlgorithm_Generic::MoveMakesSense(

+        size_t dstBlockIndex, VkDeviceSize dstOffset,

+        size_t srcBlockIndex, VkDeviceSize srcOffset)

+{

+    if(dstBlockIndex < srcBlockIndex)

+    {

+        return true;

+    }

+    if(dstBlockIndex > srcBlockIndex)

+    {

+        return false;

+    }

+    if(dstOffset < srcOffset)

+    {

+        return true;

+    }

+    return false;

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaDefragmentationAlgorithm_Fast

+

+VmaDefragmentationAlgorithm_Fast::VmaDefragmentationAlgorithm_Fast(

+    VmaAllocator hAllocator,

+    VmaBlockVector* pBlockVector,

+    uint32_t currentFrameIndex,

+    bool overlappingMoveSupported) :

+    VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),

+    m_OverlappingMoveSupported(overlappingMoveSupported),

+    m_AllocationCount(0),

+    m_AllAllocations(false),

+    m_BytesMoved(0),

+    m_AllocationsMoved(0),

+    m_BlockInfos(VmaStlAllocator<BlockInfo>(hAllocator->GetAllocationCallbacks()))

+{

+    VMA_ASSERT(VMA_DEBUG_MARGIN == 0);

+

+}

+

+VmaDefragmentationAlgorithm_Fast::~VmaDefragmentationAlgorithm_Fast()

+{

+}

+

+VkResult VmaDefragmentationAlgorithm_Fast::Defragment(

+    VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,

+    VkDeviceSize maxBytesToMove,

+    uint32_t maxAllocationsToMove,

+    VmaDefragmentationFlags flags)

+{

+    VMA_ASSERT(m_AllAllocations || m_pBlockVector->CalcAllocationCount() == m_AllocationCount);

+

+    const size_t blockCount = m_pBlockVector->GetBlockCount();

+    if(blockCount == 0 || maxBytesToMove == 0 || maxAllocationsToMove == 0)

+    {

+        return VK_SUCCESS;

+    }

+

+    PreprocessMetadata();

+

+    // Sort blocks in order from most destination.

+

+    m_BlockInfos.resize(blockCount);

+    for(size_t i = 0; i < blockCount; ++i)

+    {

+        m_BlockInfos[i].origBlockIndex = i;

+    }

+

+    VMA_SORT(m_BlockInfos.begin(), m_BlockInfos.end(), [this](const BlockInfo& lhs, const BlockInfo& rhs) -> bool {

+        return m_pBlockVector->GetBlock(lhs.origBlockIndex)->m_pMetadata->GetSumFreeSize() <

+            m_pBlockVector->GetBlock(rhs.origBlockIndex)->m_pMetadata->GetSumFreeSize();

+    });

+

+    // THE MAIN ALGORITHM

+

+    FreeSpaceDatabase freeSpaceDb;

+

+    size_t dstBlockInfoIndex = 0;

+    size_t dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;

+    VmaDeviceMemoryBlock* pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);

+    VmaBlockMetadata_Generic* pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;

+    VkDeviceSize dstBlockSize = pDstMetadata->GetSize();

+    VkDeviceSize dstOffset = 0;

+

+    bool end = false;

+    for(size_t srcBlockInfoIndex = 0; !end && srcBlockInfoIndex < blockCount; ++srcBlockInfoIndex)

+    {

+        const size_t srcOrigBlockIndex = m_BlockInfos[srcBlockInfoIndex].origBlockIndex;

+        VmaDeviceMemoryBlock* const pSrcBlock = m_pBlockVector->GetBlock(srcOrigBlockIndex);

+        VmaBlockMetadata_Generic* const pSrcMetadata = (VmaBlockMetadata_Generic*)pSrcBlock->m_pMetadata;

+        for(VmaSuballocationList::iterator srcSuballocIt = pSrcMetadata->m_Suballocations.begin();

+            !end && srcSuballocIt != pSrcMetadata->m_Suballocations.end(); )

+        {

+            VmaAllocation_T* const pAlloc = srcSuballocIt->hAllocation;

+            const VkDeviceSize srcAllocAlignment = pAlloc->GetAlignment();

+            const VkDeviceSize srcAllocSize = srcSuballocIt->size;

+            if(m_AllocationsMoved == maxAllocationsToMove ||

+                m_BytesMoved + srcAllocSize > maxBytesToMove)

+            {

+                end = true;

+                break;

+            }

+            const VkDeviceSize srcAllocOffset = srcSuballocIt->offset;

+

+            VmaDefragmentationMove move = {};

+            // Try to place it in one of free spaces from the database.

+            size_t freeSpaceInfoIndex;

+            VkDeviceSize dstAllocOffset;

+            if(freeSpaceDb.Fetch(srcAllocAlignment, srcAllocSize,

+                freeSpaceInfoIndex, dstAllocOffset))

+            {

+                size_t freeSpaceOrigBlockIndex = m_BlockInfos[freeSpaceInfoIndex].origBlockIndex;

+                VmaDeviceMemoryBlock* pFreeSpaceBlock = m_pBlockVector->GetBlock(freeSpaceOrigBlockIndex);

+                VmaBlockMetadata_Generic* pFreeSpaceMetadata = (VmaBlockMetadata_Generic*)pFreeSpaceBlock->m_pMetadata;

+

+                // Same block

+                if(freeSpaceInfoIndex == srcBlockInfoIndex)

+                {

+                    VMA_ASSERT(dstAllocOffset <= srcAllocOffset);

+

+                    // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.

+

+                    VmaSuballocation suballoc = *srcSuballocIt;

+                    suballoc.offset = dstAllocOffset;

+                    suballoc.hAllocation->ChangeOffset(dstAllocOffset);

+                    m_BytesMoved += srcAllocSize;

+                    ++m_AllocationsMoved;

+

+                    VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;

+                    ++nextSuballocIt;

+                    pSrcMetadata->m_Suballocations.erase(srcSuballocIt);

+                    srcSuballocIt = nextSuballocIt;

+

+                    InsertSuballoc(pFreeSpaceMetadata, suballoc);

+

+                    move.srcBlockIndex = srcOrigBlockIndex;

+                    move.dstBlockIndex = freeSpaceOrigBlockIndex;

+                    move.srcOffset = srcAllocOffset;

+                    move.dstOffset = dstAllocOffset;

+                    move.size = srcAllocSize;

+

+                    moves.push_back(move);

+                }

+                // Different block

+                else

+                {

+                    // MOVE OPTION 2: Move the allocation to a different block.

+

+                    VMA_ASSERT(freeSpaceInfoIndex < srcBlockInfoIndex);

+

+                    VmaSuballocation suballoc = *srcSuballocIt;

+                    suballoc.offset = dstAllocOffset;

+                    suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pFreeSpaceBlock, dstAllocOffset);

+                    m_BytesMoved += srcAllocSize;

+                    ++m_AllocationsMoved;

+

+                    VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;

+                    ++nextSuballocIt;

+                    pSrcMetadata->m_Suballocations.erase(srcSuballocIt);

+                    srcSuballocIt = nextSuballocIt;

+

+                    InsertSuballoc(pFreeSpaceMetadata, suballoc);

+

+                    move.srcBlockIndex = srcOrigBlockIndex;

+                    move.dstBlockIndex = freeSpaceOrigBlockIndex;

+                    move.srcOffset = srcAllocOffset;

+                    move.dstOffset = dstAllocOffset;

+                    move.size = srcAllocSize;

+

+                    moves.push_back(move);

+                }

+            }

+            else

+            {

+                dstAllocOffset = VmaAlignUp(dstOffset, srcAllocAlignment);

+

+                // If the allocation doesn't fit before the end of dstBlock, forward to next block.

+                while(dstBlockInfoIndex < srcBlockInfoIndex &&

+                    dstAllocOffset + srcAllocSize > dstBlockSize)

+                {

+                    // But before that, register remaining free space at the end of dst block.

+                    freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, dstBlockSize - dstOffset);

+

+                    ++dstBlockInfoIndex;

+                    dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;

+                    pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);

+                    pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;

+                    dstBlockSize = pDstMetadata->GetSize();

+                    dstOffset = 0;

+                    dstAllocOffset = 0;

+                }

+

+                // Same block

+                if(dstBlockInfoIndex == srcBlockInfoIndex)

+                {

+                    VMA_ASSERT(dstAllocOffset <= srcAllocOffset);

+

+                    const bool overlap = dstAllocOffset + srcAllocSize > srcAllocOffset;

+

+                    bool skipOver = overlap;

+                    if(overlap && m_OverlappingMoveSupported && dstAllocOffset < srcAllocOffset)

+                    {

+                        // If destination and source place overlap, skip if it would move it

+                        // by only < 1/64 of its size.

+                        skipOver = (srcAllocOffset - dstAllocOffset) * 64 < srcAllocSize;

+                    }

+

+                    if(skipOver)

+                    {

+                        freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, srcAllocOffset - dstOffset);

+

+                        dstOffset = srcAllocOffset + srcAllocSize;

+                        ++srcSuballocIt;

+                    }

+                    // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.

+                    else

+                    {

+                        srcSuballocIt->offset = dstAllocOffset;

+                        srcSuballocIt->hAllocation->ChangeOffset(dstAllocOffset);

+                        dstOffset = dstAllocOffset + srcAllocSize;

+                        m_BytesMoved += srcAllocSize;

+                        ++m_AllocationsMoved;

+                        ++srcSuballocIt;

+

+                        move.srcBlockIndex = srcOrigBlockIndex;

+                        move.dstBlockIndex = dstOrigBlockIndex;

+                        move.srcOffset = srcAllocOffset;

+                        move.dstOffset = dstAllocOffset;

+                        move.size = srcAllocSize;

+

+                        moves.push_back(move);

+                    }

+                }

+                // Different block

+                else

+                {

+                    // MOVE OPTION 2: Move the allocation to a different block.

+

+                    VMA_ASSERT(dstBlockInfoIndex < srcBlockInfoIndex);

+                    VMA_ASSERT(dstAllocOffset + srcAllocSize <= dstBlockSize);

+

+                    VmaSuballocation suballoc = *srcSuballocIt;

+                    suballoc.offset = dstAllocOffset;

+                    suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlock, dstAllocOffset);

+                    dstOffset = dstAllocOffset + srcAllocSize;

+                    m_BytesMoved += srcAllocSize;

+                    ++m_AllocationsMoved;

+

+                    VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;

+                    ++nextSuballocIt;

+                    pSrcMetadata->m_Suballocations.erase(srcSuballocIt);

+                    srcSuballocIt = nextSuballocIt;

+

+                    pDstMetadata->m_Suballocations.push_back(suballoc);

+

+                    move.srcBlockIndex = srcOrigBlockIndex;

+                    move.dstBlockIndex = dstOrigBlockIndex;

+                    move.srcOffset = srcAllocOffset;

+                    move.dstOffset = dstAllocOffset;

+                    move.size = srcAllocSize;

+

+                    moves.push_back(move);

+                }

+            }

+        }

+    }

+

+    m_BlockInfos.clear();

+

+    PostprocessMetadata();

+

+    return VK_SUCCESS;

+}

+

+void VmaDefragmentationAlgorithm_Fast::PreprocessMetadata()

+{

+    const size_t blockCount = m_pBlockVector->GetBlockCount();

+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)

+    {

+        VmaBlockMetadata_Generic* const pMetadata =

+            (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;

+        pMetadata->m_FreeCount = 0;

+        pMetadata->m_SumFreeSize = pMetadata->GetSize();

+        pMetadata->m_FreeSuballocationsBySize.clear();

+        for(VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();

+            it != pMetadata->m_Suballocations.end(); )

+        {

+            if(it->type == VMA_SUBALLOCATION_TYPE_FREE)

+            {

+                VmaSuballocationList::iterator nextIt = it;

+                ++nextIt;

+                pMetadata->m_Suballocations.erase(it);

+                it = nextIt;

+            }

+            else

+            {

+                ++it;

+            }

+        }

+    }

+}

+

+void VmaDefragmentationAlgorithm_Fast::PostprocessMetadata()

+{

+    const size_t blockCount = m_pBlockVector->GetBlockCount();

+    for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)

+    {

+        VmaBlockMetadata_Generic* const pMetadata =

+            (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;

+        const VkDeviceSize blockSize = pMetadata->GetSize();

+

+        // No allocations in this block - entire area is free.

+        if(pMetadata->m_Suballocations.empty())

+        {

+            pMetadata->m_FreeCount = 1;

+            //pMetadata->m_SumFreeSize is already set to blockSize.

+            VmaSuballocation suballoc = {

+                0, // offset

+                blockSize, // size

+                VMA_NULL, // hAllocation

+                VMA_SUBALLOCATION_TYPE_FREE };

+            pMetadata->m_Suballocations.push_back(suballoc);

+            pMetadata->RegisterFreeSuballocation(pMetadata->m_Suballocations.begin());

+        }

+        // There are some allocations in this block.

+        else

+        {

+            VkDeviceSize offset = 0;

+            VmaSuballocationList::iterator it;

+            for(it = pMetadata->m_Suballocations.begin();

+                it != pMetadata->m_Suballocations.end();

+                ++it)

+            {

+                VMA_ASSERT(it->type != VMA_SUBALLOCATION_TYPE_FREE);

+                VMA_ASSERT(it->offset >= offset);

+

+                // Need to insert preceding free space.

+                if(it->offset > offset)

+                {

+                    ++pMetadata->m_FreeCount;

+                    const VkDeviceSize freeSize = it->offset - offset;

+                    VmaSuballocation suballoc = {

+                        offset, // offset

+                        freeSize, // size

+                        VMA_NULL, // hAllocation

+                        VMA_SUBALLOCATION_TYPE_FREE };

+                    VmaSuballocationList::iterator precedingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);

+                    if(freeSize >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

+                    {

+                        pMetadata->m_FreeSuballocationsBySize.push_back(precedingFreeIt);

+                    }

+                }

+

+                pMetadata->m_SumFreeSize -= it->size;

+                offset = it->offset + it->size;

+            }

+

+            // Need to insert trailing free space.

+            if(offset < blockSize)

+            {

+                ++pMetadata->m_FreeCount;

+                const VkDeviceSize freeSize = blockSize - offset;

+                VmaSuballocation suballoc = {

+                    offset, // offset

+                    freeSize, // size

+                    VMA_NULL, // hAllocation

+                    VMA_SUBALLOCATION_TYPE_FREE };

+                VMA_ASSERT(it == pMetadata->m_Suballocations.end());

+                VmaSuballocationList::iterator trailingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);

+                if(freeSize > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)

+                {

+                    pMetadata->m_FreeSuballocationsBySize.push_back(trailingFreeIt);

+                }

+            }

+

+            VMA_SORT(

+                pMetadata->m_FreeSuballocationsBySize.begin(),

+                pMetadata->m_FreeSuballocationsBySize.end(),

+                VmaSuballocationItemSizeLess());

+        }

+

+        VMA_HEAVY_ASSERT(pMetadata->Validate());

+    }

+}

+

+void VmaDefragmentationAlgorithm_Fast::InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc)

+{

+    // TODO: Optimize somehow. Remember iterator instead of searching for it linearly.

+    VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();

+    while(it != pMetadata->m_Suballocations.end())

+    {

+        if(it->offset < suballoc.offset)

+        {

+            ++it;

+        }

+    }

+    pMetadata->m_Suballocations.insert(it, suballoc);

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaBlockVectorDefragmentationContext

+

+VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext(

+    VmaAllocator hAllocator,

+    VmaPool hCustomPool,

+    VmaBlockVector* pBlockVector,

+    uint32_t currFrameIndex) :

+    res(VK_SUCCESS),

+    mutexLocked(false),

+    blockContexts(VmaStlAllocator<VmaBlockDefragmentationContext>(hAllocator->GetAllocationCallbacks())),

+    defragmentationMoves(VmaStlAllocator<VmaDefragmentationMove>(hAllocator->GetAllocationCallbacks())),

+    defragmentationMovesProcessed(0),

+    defragmentationMovesCommitted(0),

+    hasDefragmentationPlan(0),

+    m_hAllocator(hAllocator),

+    m_hCustomPool(hCustomPool),

+    m_pBlockVector(pBlockVector),

+    m_CurrFrameIndex(currFrameIndex),

+    m_pAlgorithm(VMA_NULL),

+    m_Allocations(VmaStlAllocator<AllocInfo>(hAllocator->GetAllocationCallbacks())),

+    m_AllAllocations(false)

+{

+}

+

+VmaBlockVectorDefragmentationContext::~VmaBlockVectorDefragmentationContext()

+{

+    vma_delete(m_hAllocator, m_pAlgorithm);

+}

+

+void VmaBlockVectorDefragmentationContext::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)

+{

+    AllocInfo info = { hAlloc, pChanged };

+    m_Allocations.push_back(info);

+}

+

+void VmaBlockVectorDefragmentationContext::Begin(bool overlappingMoveSupported, VmaDefragmentationFlags flags)

+{

+    const bool allAllocations = m_AllAllocations ||

+        m_Allocations.size() == m_pBlockVector->CalcAllocationCount();

+

+    /********************************

+    HERE IS THE CHOICE OF DEFRAGMENTATION ALGORITHM.

+    ********************************/

+

+    /*

+    Fast algorithm is supported only when certain criteria are met:

+    - VMA_DEBUG_MARGIN is 0.

+    - All allocations in this block vector are moveable.

+    - There is no possibility of image/buffer granularity conflict.

+    - The defragmentation is not incremental

+    */

+    if(VMA_DEBUG_MARGIN == 0 &&

+        allAllocations &&

+        !m_pBlockVector->IsBufferImageGranularityConflictPossible() &&

+        !(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL))

+    {

+        m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Fast)(

+            m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);

+    }

+    else

+    {

+        m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Generic)(

+            m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);

+    }

+

+    if(allAllocations)

+    {

+        m_pAlgorithm->AddAll();

+    }

+    else

+    {

+        for(size_t i = 0, count = m_Allocations.size(); i < count; ++i)

+        {

+            m_pAlgorithm->AddAllocation(m_Allocations[i].hAlloc, m_Allocations[i].pChanged);

+        }

+    }

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaDefragmentationContext

+

+VmaDefragmentationContext_T::VmaDefragmentationContext_T(

+    VmaAllocator hAllocator,

+    uint32_t currFrameIndex,

+    uint32_t flags,

+    VmaDefragmentationStats* pStats) :

+    m_hAllocator(hAllocator),

+    m_CurrFrameIndex(currFrameIndex),

+    m_Flags(flags),

+    m_pStats(pStats),

+    m_CustomPoolContexts(VmaStlAllocator<VmaBlockVectorDefragmentationContext*>(hAllocator->GetAllocationCallbacks()))

+{

+    memset(m_DefaultPoolContexts, 0, sizeof(m_DefaultPoolContexts));

+}

+

+VmaDefragmentationContext_T::~VmaDefragmentationContext_T()

+{

+    for(size_t i = m_CustomPoolContexts.size(); i--; )

+    {

+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[i];

+        pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_Flags, m_pStats);

+        vma_delete(m_hAllocator, pBlockVectorCtx);

+    }

+    for(size_t i = m_hAllocator->m_MemProps.memoryTypeCount; i--; )

+    {

+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[i];

+        if(pBlockVectorCtx)

+        {

+            pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_Flags, m_pStats);

+            vma_delete(m_hAllocator, pBlockVectorCtx);

+        }

+    }

+}

+

+void VmaDefragmentationContext_T::AddPools(uint32_t poolCount, const VmaPool* pPools)

+{

+    for(uint32_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)

+    {

+        VmaPool pool = pPools[poolIndex];

+        VMA_ASSERT(pool);

+        // Pools with algorithm other than default are not defragmented.

+        if(pool->m_BlockVector.GetAlgorithm() == 0)

+        {

+            VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;

+

+            for(size_t i = m_CustomPoolContexts.size(); i--; )

+            {

+                if(m_CustomPoolContexts[i]->GetCustomPool() == pool)

+                {

+                    pBlockVectorDefragCtx = m_CustomPoolContexts[i];

+                    break;

+                }

+            }

+

+            if(!pBlockVectorDefragCtx)

+            {

+                pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(

+                    m_hAllocator,

+                    pool,

+                    &pool->m_BlockVector,

+                    m_CurrFrameIndex);

+                m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);

+            }

+

+            pBlockVectorDefragCtx->AddAll();

+        }

+    }

+}

+

+void VmaDefragmentationContext_T::AddAllocations(

+    uint32_t allocationCount,

+    const VmaAllocation* pAllocations,

+    VkBool32* pAllocationsChanged)

+{

+    // Dispatch pAllocations among defragmentators. Create them when necessary.

+    for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)

+    {

+        const VmaAllocation hAlloc = pAllocations[allocIndex];

+        VMA_ASSERT(hAlloc);

+        // DedicatedAlloc cannot be defragmented.

+        if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&

+            // Lost allocation cannot be defragmented.

+            (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))

+        {

+            VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;

+

+            const VmaPool hAllocPool = hAlloc->GetBlock()->GetParentPool();

+            // This allocation belongs to custom pool.

+            if(hAllocPool != VK_NULL_HANDLE)

+            {

+                // Pools with algorithm other than default are not defragmented.

+                if(hAllocPool->m_BlockVector.GetAlgorithm() == 0)

+                {

+                    for(size_t i = m_CustomPoolContexts.size(); i--; )

+                    {

+                        if(m_CustomPoolContexts[i]->GetCustomPool() == hAllocPool)

+                        {

+                            pBlockVectorDefragCtx = m_CustomPoolContexts[i];

+                            break;

+                        }

+                    }

+                    if(!pBlockVectorDefragCtx)

+                    {

+                        pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(

+                            m_hAllocator,

+                            hAllocPool,

+                            &hAllocPool->m_BlockVector,

+                            m_CurrFrameIndex);

+                        m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);

+                    }

+                }

+            }

+            // This allocation belongs to default pool.

+            else

+            {

+                const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();

+                pBlockVectorDefragCtx = m_DefaultPoolContexts[memTypeIndex];

+                if(!pBlockVectorDefragCtx)

+                {

+                    pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(

+                        m_hAllocator,

+                        VMA_NULL, // hCustomPool

+                        m_hAllocator->m_pBlockVectors[memTypeIndex],

+                        m_CurrFrameIndex);

+                    m_DefaultPoolContexts[memTypeIndex] = pBlockVectorDefragCtx;

+                }

+            }

+

+            if(pBlockVectorDefragCtx)

+            {

+                VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?

+                    &pAllocationsChanged[allocIndex] : VMA_NULL;

+                pBlockVectorDefragCtx->AddAllocation(hAlloc, pChanged);

+            }

+        }

+    }

+}

+

+VkResult VmaDefragmentationContext_T::Defragment(

+    VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,

+    VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,

+    VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats, VmaDefragmentationFlags flags)

+{

+    if(pStats)

+    {

+        memset(pStats, 0, sizeof(VmaDefragmentationStats));

+    }

+

+    if(flags & VMA_DEFRAGMENTATION_FLAG_INCREMENTAL)

+    {

+        // For incremental defragmetnations, we just earmark how much we can move

+        // The real meat is in the defragmentation steps

+        m_MaxCpuBytesToMove = maxCpuBytesToMove;

+        m_MaxCpuAllocationsToMove = maxCpuAllocationsToMove;

+

+        m_MaxGpuBytesToMove = maxGpuBytesToMove;

+        m_MaxGpuAllocationsToMove = maxGpuAllocationsToMove;

+

+        if(m_MaxCpuBytesToMove == 0 && m_MaxCpuAllocationsToMove == 0 &&

+            m_MaxGpuBytesToMove == 0 && m_MaxGpuAllocationsToMove == 0)

+            return VK_SUCCESS;

+

+        return VK_NOT_READY;

+    }

+

+    if(commandBuffer == VK_NULL_HANDLE)

+    {

+        maxGpuBytesToMove = 0;

+        maxGpuAllocationsToMove = 0;

+    }

+

+    VkResult res = VK_SUCCESS;

+

+    // Process default pools.

+    for(uint32_t memTypeIndex = 0;

+        memTypeIndex < m_hAllocator->GetMemoryTypeCount() && res >= VK_SUCCESS;

+        ++memTypeIndex)

+    {

+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];

+        if(pBlockVectorCtx)

+        {

+            VMA_ASSERT(pBlockVectorCtx->GetBlockVector());

+            pBlockVectorCtx->GetBlockVector()->Defragment(

+                pBlockVectorCtx,

+                pStats, flags,

+                maxCpuBytesToMove, maxCpuAllocationsToMove,

+                maxGpuBytesToMove, maxGpuAllocationsToMove,

+                commandBuffer);

+            if(pBlockVectorCtx->res != VK_SUCCESS)

+            {

+                res = pBlockVectorCtx->res;

+            }

+        }

+    }

+

+    // Process custom pools.

+    for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();

+        customCtxIndex < customCtxCount && res >= VK_SUCCESS;

+        ++customCtxIndex)

+    {

+        VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];

+        VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());

+        pBlockVectorCtx->GetBlockVector()->Defragment(

+            pBlockVectorCtx,

+            pStats, flags,

+            maxCpuBytesToMove, maxCpuAllocationsToMove,

+            maxGpuBytesToMove, maxGpuAllocationsToMove,

+            commandBuffer);

+        if(pBlockVectorCtx->res != VK_SUCCESS)

+        {

+            res = pBlockVectorCtx->res;

+        }

+    }

+

+    return res;

+}

+

+VkResult VmaDefragmentationContext_T::DefragmentPassBegin(VmaDefragmentationPassInfo* pInfo)

+{

+    VmaDefragmentationPassMoveInfo* pCurrentMove = pInfo->pMoves;

+    uint32_t movesLeft = pInfo->moveCount;

+

+    // Process default pools.

+    for(uint32_t memTypeIndex = 0;

+        memTypeIndex < m_hAllocator->GetMemoryTypeCount();

+        ++memTypeIndex)

+    {

+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];

+        if(pBlockVectorCtx)

+        {

+            VMA_ASSERT(pBlockVectorCtx->GetBlockVector());

+

+            if(!pBlockVectorCtx->hasDefragmentationPlan)

+            {

+                pBlockVectorCtx->GetBlockVector()->Defragment(

+                    pBlockVectorCtx,

+                    m_pStats, m_Flags,

+                    m_MaxCpuBytesToMove, m_MaxCpuAllocationsToMove,

+                    m_MaxGpuBytesToMove, m_MaxGpuAllocationsToMove,

+                    VK_NULL_HANDLE);

+

+                if(pBlockVectorCtx->res < VK_SUCCESS)

+                    continue;

+

+                pBlockVectorCtx->hasDefragmentationPlan = true;

+            }

+

+            const uint32_t processed = pBlockVectorCtx->GetBlockVector()->ProcessDefragmentations(

+                pBlockVectorCtx,

+                pCurrentMove, movesLeft);

+

+            movesLeft -= processed;

+            pCurrentMove += processed;

+        }

+    }

+

+    // Process custom pools.

+    for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();

+        customCtxIndex < customCtxCount;

+        ++customCtxIndex)

+    {

+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];

+        VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());

+

+        if(!pBlockVectorCtx->hasDefragmentationPlan)

+        {

+            pBlockVectorCtx->GetBlockVector()->Defragment(

+                pBlockVectorCtx,

+                m_pStats, m_Flags,

+                m_MaxCpuBytesToMove, m_MaxCpuAllocationsToMove,

+                m_MaxGpuBytesToMove, m_MaxGpuAllocationsToMove,

+                VK_NULL_HANDLE);

+

+            if(pBlockVectorCtx->res < VK_SUCCESS)

+                continue;

+

+            pBlockVectorCtx->hasDefragmentationPlan = true;

+        }

+

+        const uint32_t processed = pBlockVectorCtx->GetBlockVector()->ProcessDefragmentations(

+            pBlockVectorCtx,

+            pCurrentMove, movesLeft);

+

+        movesLeft -= processed;

+        pCurrentMove += processed;

+    }

+

+    pInfo->moveCount = pInfo->moveCount - movesLeft;

+

+    return VK_SUCCESS;

+}

+VkResult VmaDefragmentationContext_T::DefragmentPassEnd()

+{

+    VkResult res = VK_SUCCESS;

+

+    // Process default pools.

+    for(uint32_t memTypeIndex = 0;

+        memTypeIndex < m_hAllocator->GetMemoryTypeCount();

+        ++memTypeIndex)

+    {

+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];

+        if(pBlockVectorCtx)

+        {

+            VMA_ASSERT(pBlockVectorCtx->GetBlockVector());

+

+            if(!pBlockVectorCtx->hasDefragmentationPlan)

+            {

+                res = VK_NOT_READY;

+                continue;

+            }

+

+            pBlockVectorCtx->GetBlockVector()->CommitDefragmentations(

+                pBlockVectorCtx, m_pStats);

+

+            if(pBlockVectorCtx->defragmentationMoves.size() != pBlockVectorCtx->defragmentationMovesCommitted)

+                res = VK_NOT_READY;

+        }

+    }

+

+    // Process custom pools.

+    for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();

+        customCtxIndex < customCtxCount;

+        ++customCtxIndex)

+    {

+        VmaBlockVectorDefragmentationContext *pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];

+        VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());

+

+        if(!pBlockVectorCtx->hasDefragmentationPlan)

+        {

+            res = VK_NOT_READY;

+            continue;

+        }

+

+        pBlockVectorCtx->GetBlockVector()->CommitDefragmentations(

+            pBlockVectorCtx, m_pStats);

+

+        if(pBlockVectorCtx->defragmentationMoves.size() != pBlockVectorCtx->defragmentationMovesCommitted)

+            res = VK_NOT_READY;

+    }

+

+    return res;

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaRecorder

+

+#if VMA_RECORDING_ENABLED

+

+VmaRecorder::VmaRecorder() :

+    m_UseMutex(true),

+    m_Flags(0),

+    m_File(VMA_NULL),

+    m_RecordingStartTime(std::chrono::high_resolution_clock::now())

+{

+}

+

+VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)

+{

+    m_UseMutex = useMutex;

+    m_Flags = settings.flags;

+

+#if defined(_WIN32)

+    // Open file for writing.

+    errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");

+

+    if(err != 0)

+    {

+        return VK_ERROR_INITIALIZATION_FAILED;

+    }

+#else

+    // Open file for writing.

+    m_File = fopen(settings.pFilePath, "wb");

+

+    if(m_File == 0)

+    {

+        return VK_ERROR_INITIALIZATION_FAILED;

+    }

+#endif

+

+    // Write header.

+    fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");

+    fprintf(m_File, "%s\n", "1,8");

+

+    return VK_SUCCESS;

+}

+

+VmaRecorder::~VmaRecorder()

+{

+    if(m_File != VMA_NULL)

+    {

+        fclose(m_File);

+    }

+}

+

+void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);

+    Flush();

+}

+

+void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);

+    Flush();

+}

+

+void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,

+        createInfo.memoryTypeIndex,

+        createInfo.flags,

+        createInfo.blockSize,

+        (uint64_t)createInfo.minBlockCount,

+        (uint64_t)createInfo.maxBlockCount,

+        createInfo.frameInUseCount,

+        pool);

+    Flush();

+}

+

+void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,

+        pool);

+    Flush();

+}

+

+void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,

+        const VkMemoryRequirements& vkMemReq,

+        const VmaAllocationCreateInfo& createInfo,

+        VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);

+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,

+        vkMemReq.size,

+        vkMemReq.alignment,

+        vkMemReq.memoryTypeBits,

+        createInfo.flags,

+        createInfo.usage,

+        createInfo.requiredFlags,

+        createInfo.preferredFlags,

+        createInfo.memoryTypeBits,

+        createInfo.pool,

+        allocation,

+        userDataStr.GetString());

+    Flush();

+}

+

+void VmaRecorder::RecordAllocateMemoryPages(uint32_t frameIndex,

+    const VkMemoryRequirements& vkMemReq,

+    const VmaAllocationCreateInfo& createInfo,

+    uint64_t allocationCount,

+    const VmaAllocation* pAllocations)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);

+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryPages,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,", callParams.threadId, callParams.time, frameIndex,

+        vkMemReq.size,

+        vkMemReq.alignment,

+        vkMemReq.memoryTypeBits,

+        createInfo.flags,

+        createInfo.usage,

+        createInfo.requiredFlags,

+        createInfo.preferredFlags,

+        createInfo.memoryTypeBits,

+        createInfo.pool);

+    PrintPointerList(allocationCount, pAllocations);

+    fprintf(m_File, ",%s\n", userDataStr.GetString());

+    Flush();

+}

+

+void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,

+    const VkMemoryRequirements& vkMemReq,

+    bool requiresDedicatedAllocation,

+    bool prefersDedicatedAllocation,

+    const VmaAllocationCreateInfo& createInfo,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);

+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForBuffer,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,

+        vkMemReq.size,

+        vkMemReq.alignment,

+        vkMemReq.memoryTypeBits,

+        requiresDedicatedAllocation ? 1 : 0,

+        prefersDedicatedAllocation ? 1 : 0,

+        createInfo.flags,

+        createInfo.usage,

+        createInfo.requiredFlags,

+        createInfo.preferredFlags,

+        createInfo.memoryTypeBits,

+        createInfo.pool,

+        allocation,

+        userDataStr.GetString());

+    Flush();

+}

+

+void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,

+    const VkMemoryRequirements& vkMemReq,

+    bool requiresDedicatedAllocation,

+    bool prefersDedicatedAllocation,

+    const VmaAllocationCreateInfo& createInfo,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    UserDataString userDataStr(createInfo.flags, createInfo.pUserData);

+    fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForImage,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,

+        vkMemReq.size,

+        vkMemReq.alignment,

+        vkMemReq.memoryTypeBits,

+        requiresDedicatedAllocation ? 1 : 0,

+        prefersDedicatedAllocation ? 1 : 0,

+        createInfo.flags,

+        createInfo.usage,

+        createInfo.requiredFlags,

+        createInfo.preferredFlags,

+        createInfo.memoryTypeBits,

+        createInfo.pool,

+        allocation,

+        userDataStr.GetString());

+    Flush();

+}

+

+void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordFreeMemoryPages(uint32_t frameIndex,

+    uint64_t allocationCount,

+    const VmaAllocation* pAllocations)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaFreeMemoryPages,", callParams.threadId, callParams.time, frameIndex);

+    PrintPointerList(allocationCount, pAllocations);

+    fprintf(m_File, "\n");

+    Flush();

+}

+

+void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,

+    VmaAllocation allocation,

+    const void* pUserData)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    UserDataString userDataStr(

+        allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,

+        pUserData);

+    fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,

+        allocation,

+        userDataStr.GetString());

+    Flush();

+}

+

+void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordMapMemory(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,

+    VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,

+        allocation,

+        offset,

+        size);

+    Flush();

+}

+

+void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,

+    VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,

+        allocation,

+        offset,

+        size);

+    Flush();

+}

+

+void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,

+    const VkBufferCreateInfo& bufCreateInfo,

+    const VmaAllocationCreateInfo& allocCreateInfo,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);

+    fprintf(m_File, "%u,%.3f,%u,vmaCreateBuffer,%u,%llu,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,

+        bufCreateInfo.flags,

+        bufCreateInfo.size,

+        bufCreateInfo.usage,

+        bufCreateInfo.sharingMode,

+        allocCreateInfo.flags,

+        allocCreateInfo.usage,

+        allocCreateInfo.requiredFlags,

+        allocCreateInfo.preferredFlags,

+        allocCreateInfo.memoryTypeBits,

+        allocCreateInfo.pool,

+        allocation,

+        userDataStr.GetString());

+    Flush();

+}

+

+void VmaRecorder::RecordCreateImage(uint32_t frameIndex,

+    const VkImageCreateInfo& imageCreateInfo,

+    const VmaAllocationCreateInfo& allocCreateInfo,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);

+    fprintf(m_File, "%u,%.3f,%u,vmaCreateImage,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,

+        imageCreateInfo.flags,

+        imageCreateInfo.imageType,

+        imageCreateInfo.format,

+        imageCreateInfo.extent.width,

+        imageCreateInfo.extent.height,

+        imageCreateInfo.extent.depth,

+        imageCreateInfo.mipLevels,

+        imageCreateInfo.arrayLayers,

+        imageCreateInfo.samples,

+        imageCreateInfo.tiling,

+        imageCreateInfo.usage,

+        imageCreateInfo.sharingMode,

+        imageCreateInfo.initialLayout,

+        allocCreateInfo.flags,

+        allocCreateInfo.usage,

+        allocCreateInfo.requiredFlags,

+        allocCreateInfo.preferredFlags,

+        allocCreateInfo.memoryTypeBits,

+        allocCreateInfo.pool,

+        allocation,

+        userDataStr.GetString());

+    Flush();

+}

+

+void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,

+    VmaAllocation allocation)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,

+        allocation);

+    Flush();

+}

+

+void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,

+    VmaPool pool)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,

+        pool);

+    Flush();

+}

+

+void VmaRecorder::RecordDefragmentationBegin(uint32_t frameIndex,

+    const VmaDefragmentationInfo2& info,

+    VmaDefragmentationContext ctx)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationBegin,%u,", callParams.threadId, callParams.time, frameIndex,

+        info.flags);

+    PrintPointerList(info.allocationCount, info.pAllocations);

+    fprintf(m_File, ",");

+    PrintPointerList(info.poolCount, info.pPools);

+    fprintf(m_File, ",%llu,%u,%llu,%u,%p,%p\n",

+        info.maxCpuBytesToMove,

+        info.maxCpuAllocationsToMove,

+        info.maxGpuBytesToMove,

+        info.maxGpuAllocationsToMove,

+        info.commandBuffer,

+        ctx);

+    Flush();

+}

+

+void VmaRecorder::RecordDefragmentationEnd(uint32_t frameIndex,

+    VmaDefragmentationContext ctx)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationEnd,%p\n", callParams.threadId, callParams.time, frameIndex,

+        ctx);

+    Flush();

+}

+

+void VmaRecorder::RecordSetPoolName(uint32_t frameIndex,

+    VmaPool pool,

+    const char* name)

+{

+    CallParams callParams;

+    GetBasicParams(callParams);

+

+    VmaMutexLock lock(m_FileMutex, m_UseMutex);

+    fprintf(m_File, "%u,%.3f,%u,vmaSetPoolName,%p,%s\n", callParams.threadId, callParams.time, frameIndex,

+        pool, name != VMA_NULL ? name : "");

+    Flush();

+}

+

+VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)

+{

+    if(pUserData != VMA_NULL)

+    {

+        if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)

+        {

+            m_Str = (const char*)pUserData;

+        }

+        else

+        {

+            // If VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT is not specified, convert the string's memory address to a string and store it.

+            snprintf(m_PtrStr, 17, "%p", pUserData);

+            m_Str = m_PtrStr;

+        }

+    }

+    else

+    {

+        m_Str = "";

+    }

+}

+

+void VmaRecorder::WriteConfiguration(

+    const VkPhysicalDeviceProperties& devProps,

+    const VkPhysicalDeviceMemoryProperties& memProps,

+    uint32_t vulkanApiVersion,

+    bool dedicatedAllocationExtensionEnabled,

+    bool bindMemory2ExtensionEnabled,

+    bool memoryBudgetExtensionEnabled,

+    bool deviceCoherentMemoryExtensionEnabled)

+{

+    fprintf(m_File, "Config,Begin\n");

+

+    fprintf(m_File, "VulkanApiVersion,%u,%u\n", VK_VERSION_MAJOR(vulkanApiVersion), VK_VERSION_MINOR(vulkanApiVersion));

+

+    fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);

+    fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);

+    fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);

+    fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);

+    fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);

+    fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);

+

+    fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);

+    fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);

+    fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);

+

+    fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);

+    for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)

+    {

+        fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);

+        fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);

+    }

+    fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);

+    for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)

+    {

+        fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);

+        fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);

+    }

+

+    fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);

+    fprintf(m_File, "Extension,VK_KHR_bind_memory2,%u\n", bindMemory2ExtensionEnabled ? 1 : 0);

+    fprintf(m_File, "Extension,VK_EXT_memory_budget,%u\n", memoryBudgetExtensionEnabled ? 1 : 0);

+    fprintf(m_File, "Extension,VK_AMD_device_coherent_memory,%u\n", deviceCoherentMemoryExtensionEnabled ? 1 : 0);

+

+    fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);

+    fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);

+    fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);

+    fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);

+    fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);

+    fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);

+    fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);

+    fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);

+    fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);

+

+    fprintf(m_File, "Config,End\n");

+}

+

+void VmaRecorder::GetBasicParams(CallParams& outParams)

+{

+    #if defined(_WIN32)

+        outParams.threadId = GetCurrentThreadId();

+    #else

+        // Use C++11 features to get thread id and convert it to uint32_t.

+        // There is room for optimization since sstream is quite slow.

+        // Is there a better way to convert std::this_thread::get_id() to uint32_t?

+        std::thread::id thread_id = std::this_thread::get_id();

+        std::stringstream thread_id_to_string_converter;

+        thread_id_to_string_converter << thread_id;

+        std::string thread_id_as_string = thread_id_to_string_converter.str();

+        outParams.threadId = static_cast<uint32_t>(std::stoi(thread_id_as_string.c_str()));

+    #endif

+

+    auto current_time = std::chrono::high_resolution_clock::now();

+

+    outParams.time = std::chrono::duration<double, std::chrono::seconds::period>(current_time - m_RecordingStartTime).count();

+}

+

+void VmaRecorder::PrintPointerList(uint64_t count, const VmaAllocation* pItems)

+{

+    if(count)

+    {

+        fprintf(m_File, "%p", pItems[0]);

+        for(uint64_t i = 1; i < count; ++i)

+        {

+            fprintf(m_File, " %p", pItems[i]);

+        }

+    }

+}

+

+void VmaRecorder::Flush()

+{

+    if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)

+    {

+        fflush(m_File);

+    }

+}

+

+#endif // #if VMA_RECORDING_ENABLED

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaAllocationObjectAllocator

+

+VmaAllocationObjectAllocator::VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks) :

+    m_Allocator(pAllocationCallbacks, 1024)

+{

+}

+

+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);

+}

+

+////////////////////////////////////////////////////////////////////////////////

+// VmaAllocator_T

+

+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_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_PreferredLargeHeapBlockSize(0),

+    m_PhysicalDevice(pCreateInfo->physicalDevice),

+    m_CurrentFrameIndex(0),

+    m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),

+    m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),

+    m_NextPoolId(0),

+    m_GlobalMemoryTypeBits(UINT32_MAX)

+#if VMA_RECORDING_ENABLED

+    ,m_pRecorder(VMA_NULL)

+#endif

+{

+    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

+

+    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_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));

+    memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));

+

+    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_DEBUG_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(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)

+    {

+        const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);

+

+        m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(

+            this,

+            VK_NULL_HANDLE, // hParentPool

+            memTypeIndex,

+            preferredBlockSize,

+            0,

+            SIZE_MAX,

+            GetBufferImageGranularity(),

+            pCreateInfo->frameInUseCount,

+            false, // explicitBlockSize

+            false); // linearAlgorithm

+        // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,

+        // becase minBlockCount is 0.

+        m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));

+

+    }

+}

+

+VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)

+{

+    VkResult res = VK_SUCCESS;

+

+    if(pCreateInfo->pRecordSettings != VMA_NULL &&

+        !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))

+    {

+#if VMA_RECORDING_ENABLED

+        m_pRecorder = vma_new(this, VmaRecorder)();

+        res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);

+        if(res != VK_SUCCESS)

+        {

+            return res;

+        }

+        m_pRecorder->WriteConfiguration(

+            m_PhysicalDeviceProperties,

+            m_MemProps,

+            m_VulkanApiVersion,

+            m_UseKhrDedicatedAllocation,

+            m_UseKhrBindMemory2,

+            m_UseExtMemoryBudget,

+            m_UseAmdDeviceCoherentMemory);

+        m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());

+#else

+        VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");

+        return VK_ERROR_FEATURE_NOT_PRESENT;

+#endif

+    }

+

+#if VMA_MEMORY_BUDGET

+    if(m_UseExtMemoryBudget)

+    {

+        UpdateVulkanBudget();

+    }

+#endif // #if VMA_MEMORY_BUDGET

+

+    return res;

+}

+

+VmaAllocator_T::~VmaAllocator_T()

+{

+#if VMA_RECORDING_ENABLED

+    if(m_pRecorder != VMA_NULL)

+    {

+        m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());

+        vma_delete(this, m_pRecorder);

+    }

+#endif

+

+    VMA_ASSERT(m_Pools.empty());

+

+    for(size_t i = GetMemoryTypeCount(); i--; )

+    {

+        if(m_pDedicatedAllocations[i] != VMA_NULL && !m_pDedicatedAllocations[i]->empty())

+        {

+            VMA_ASSERT(0 && "Unfreed dedicated allocations found.");

+        }

+

+        vma_delete(this, m_pDedicatedAllocations[i]);

+        vma_delete(this, m_pBlockVectors[i]);

+    }

+}

+

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

+}

+

+#endif // #if 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(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

+

+#undef VMA_COPY_IF_NOT_NULL

+}

+

+#if VMA_DYNAMIC_VULKAN_FUNCTIONS == 1

+

+void VmaAllocator_T::ImportVulkanFunctions_Dynamic()

+{

+#define VMA_FETCH_INSTANCE_FUNC(memberName, functionPointerType, functionNameString) \

+    if(m_VulkanFunctions.memberName == VMA_NULL) \

+        m_VulkanFunctions.memberName = \

+            (functionPointerType)vkGetInstanceProcAddr(m_hInstance, functionNameString);

+#define VMA_FETCH_DEVICE_FUNC(memberName, functionPointerType, functionNameString) \

+    if(m_VulkanFunctions.memberName == VMA_NULL) \

+        m_VulkanFunctions.memberName = \

+            (functionPointerType)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

+

+#undef VMA_FETCH_DEVICE_FUNC

+#undef VMA_FETCH_INSTANCE_FUNC

+}

+

+#endif // #if 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

+}

+

+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(

+    VkDeviceSize size,

+    VkDeviceSize alignment,

+    bool dedicatedAllocation,

+    VkBuffer dedicatedBuffer,

+    VkBufferUsageFlags dedicatedBufferUsage,

+    VkImage dedicatedImage,

+    const VmaAllocationCreateInfo& createInfo,

+    uint32_t memTypeIndex,

+    VmaSuballocationType suballocType,

+    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;

+

+    // If memory type is not HOST_VISIBLE, disable MAPPED.

+    if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&

+        (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)

+    {

+        finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;

+    }

+    // If memory is lazily allocated, it should be always dedicated.

+    if(finalCreateInfo.usage == VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED)

+    {

+        finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;

+    }

+

+    VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];

+    VMA_ASSERT(blockVector);

+

+    const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();

+    bool preferDedicatedMemory =

+        VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||

+        dedicatedAllocation ||

+        // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.

+        size > preferredBlockSize / 2;

+

+    if(preferDedicatedMemory &&

+        (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&

+        finalCreateInfo.pool == VK_NULL_HANDLE)

+    {

+        finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;

+    }

+

+    if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)

+    {

+        if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)

+        {

+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+        }

+        else

+        {

+            return AllocateDedicatedMemory(

+                size,

+                suballocType,

+                memTypeIndex,

+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,

+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,

+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,

+                finalCreateInfo.pUserData,

+                dedicatedBuffer,

+                dedicatedBufferUsage,

+                dedicatedImage,

+                allocationCount,

+                pAllocations);

+        }

+    }

+    else

+    {

+        VkResult res = blockVector->Allocate(

+            m_CurrentFrameIndex.load(),

+            size,

+            alignment,

+            finalCreateInfo,

+            suballocType,

+            allocationCount,

+            pAllocations);

+        if(res == VK_SUCCESS)

+        {

+            return res;

+        }

+

+        // 5. Try dedicated memory.

+        if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)

+        {

+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+        }

+        else

+        {

+            res = AllocateDedicatedMemory(

+                size,

+                suballocType,

+                memTypeIndex,

+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,

+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,

+                (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,

+                finalCreateInfo.pUserData,

+                dedicatedBuffer,

+                dedicatedBufferUsage,

+                dedicatedImage,

+                allocationCount,

+                pAllocations);

+            if(res == VK_SUCCESS)

+            {

+                // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.

+                VMA_DEBUG_LOG("    Allocated as DedicatedMemory");

+                return VK_SUCCESS;

+            }

+            else

+            {

+                // Everything failed: Return error code.

+                VMA_DEBUG_LOG("    vkAllocateMemory FAILED");

+                return res;

+            }

+        }

+    }

+}

+

+VkResult VmaAllocator_T::AllocateDedicatedMemory(

+    VkDeviceSize size,

+    VmaSuballocationType suballocType,

+    uint32_t memTypeIndex,

+    bool withinBudget,

+    bool map,

+    bool isUserDataString,

+    void* pUserData,

+    VkBuffer dedicatedBuffer,

+    VkBufferUsageFlags dedicatedBufferUsage,

+    VkImage dedicatedImage,

+    size_t allocationCount,

+    VmaAllocation* pAllocations)

+{

+    VMA_ASSERT(allocationCount > 0 && pAllocations);

+

+    if(withinBudget)

+    {

+        const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);

+        VmaBudget heapBudget = {};

+        GetBudget(&heapBudget, heapIndex, 1);

+        if(heapBudget.usage + size * allocationCount > heapBudget.budget)

+        {

+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+        }

+    }

+

+    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };

+    allocInfo.memoryTypeIndex = memTypeIndex;

+    allocInfo.allocationSize = size;

+

+#if VMA_DEDICATED_ALLOCATION || VMA_VULKAN_VERSION >= 1001000

+    VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };

+    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 = dedicatedBufferUsage == UINT32_MAX || // Usage flags unknown

+                (dedicatedBufferUsage & 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

+

+    size_t allocIndex;

+    VkResult res = VK_SUCCESS;

+    for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)

+    {

+        res = AllocateDedicatedMemoryPage(

+            size,

+            suballocType,

+            memTypeIndex,

+            allocInfo,

+            map,

+            isUserDataString,

+            pUserData,

+            pAllocations + allocIndex);

+        if(res != VK_SUCCESS)

+        {

+            break;

+        }

+    }

+

+    if(res == VK_SUCCESS)

+    {

+        // Register them in m_pDedicatedAllocations.

+        {

+            VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);

+            AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];

+            VMA_ASSERT(pDedicatedAllocations);

+            for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)

+            {

+                VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, 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());

+            currAlloc->SetUserData(this, VMA_NULL);

+            m_AllocationObjectAllocator.Free(currAlloc);

+        }

+

+        memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);

+    }

+

+    return res;

+}

+

+VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(

+    VkDeviceSize size,

+    VmaSuballocationType suballocType,

+    uint32_t memTypeIndex,

+    const VkMemoryAllocateInfo& allocInfo,

+    bool map,

+    bool isUserDataString,

+    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(m_CurrentFrameIndex.load(), isUserDataString);

+    (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);

+    (*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::AllocateMemory(

+    const VkMemoryRequirements& vkMemReq,

+    bool requiresDedicatedAllocation,

+    bool prefersDedicatedAllocation,

+    VkBuffer dedicatedBuffer,

+    VkBufferUsageFlags dedicatedBufferUsage,

+    VkImage dedicatedImage,

+    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_VALIDATION_FAILED_EXT;

+    }

+    if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&

+        (createInfo.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_OUT_OF_DEVICE_MEMORY;

+    }

+    if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&

+        (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)

+    {

+        VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");

+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+    }

+    if(requiresDedicatedAllocation)

+    {

+        if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)

+        {

+            VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");

+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+        }

+        if(createInfo.pool != VK_NULL_HANDLE)

+        {

+            VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");

+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+        }

+    }

+    if((createInfo.pool != VK_NULL_HANDLE) &&

+        ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))

+    {

+        VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");

+        return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+    }

+

+    if(createInfo.pool != VK_NULL_HANDLE)

+    {

+        const VkDeviceSize alignmentForPool = VMA_MAX(

+            vkMemReq.alignment,

+            GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));

+

+        VmaAllocationCreateInfo createInfoForPool = createInfo;

+        // If memory type is not HOST_VISIBLE, disable MAPPED.

+        if((createInfoForPool.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&

+            (m_MemProps.memoryTypes[createInfo.pool->m_BlockVector.GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)

+        {

+            createInfoForPool.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;

+        }

+

+        return createInfo.pool->m_BlockVector.Allocate(

+            m_CurrentFrameIndex.load(),

+            vkMemReq.size,

+            alignmentForPool,

+            createInfoForPool,

+            suballocType,

+            allocationCount,

+            pAllocations);

+    }

+    else

+    {

+        // Bit mask of memory Vulkan types acceptable for this allocation.

+        uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;

+        uint32_t memTypeIndex = UINT32_MAX;

+        VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);

+        if(res == VK_SUCCESS)

+        {

+            VkDeviceSize alignmentForMemType = VMA_MAX(

+                vkMemReq.alignment,

+                GetMemoryTypeMinAlignment(memTypeIndex));

+

+            res = AllocateMemoryOfType(

+                vkMemReq.size,

+                alignmentForMemType,

+                requiresDedicatedAllocation || prefersDedicatedAllocation,

+                dedicatedBuffer,

+                dedicatedBufferUsage,

+                dedicatedImage,

+                createInfo,

+                memTypeIndex,

+                suballocType,

+                allocationCount,

+                pAllocations);

+            // Succeeded on first try.

+            if(res == VK_SUCCESS)

+            {

+                return res;

+            }

+            // Allocation from this memory type failed. Try other compatible memory types.

+            else

+            {

+                for(;;)

+                {

+                    // Remove old memTypeIndex from list of possibilities.

+                    memoryTypeBits &= ~(1u << memTypeIndex);

+                    // Find alternative memTypeIndex.

+                    res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);

+                    if(res == VK_SUCCESS)

+                    {

+                        alignmentForMemType = VMA_MAX(

+                            vkMemReq.alignment,

+                            GetMemoryTypeMinAlignment(memTypeIndex));

+

+                        res = AllocateMemoryOfType(

+                            vkMemReq.size,

+                            alignmentForMemType,

+                            requiresDedicatedAllocation || prefersDedicatedAllocation,

+                            dedicatedBuffer,

+                            dedicatedBufferUsage,

+                            dedicatedImage,

+                            createInfo,

+                            memTypeIndex,

+                            suballocType,

+                            allocationCount,

+                            pAllocations);

+                        // Allocation from this alternative memory type succeeded.

+                        if(res == VK_SUCCESS)

+                        {

+                            return res;

+                        }

+                        // else: Allocation from this memory type failed. Try next one - next loop iteration.

+                    }

+                    // No other matching memory type index could be found.

+                    else

+                    {

+                        // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.

+                        return VK_ERROR_OUT_OF_DEVICE_MEMORY;

+                    }

+                }

+            }

+        }

+        // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.

+        else

+            return res;

+    }

+}

+

+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(TouchAllocation(allocation))

+            {

+                if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)

+                {

+                    FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);

+                }

+

+                switch(allocation->GetType())

+                {

+                case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:

+                    {

+                        VmaBlockVector* pBlockVector = VMA_NULL;

+                        VmaPool hPool = allocation->GetBlock()->GetParentPool();

+                        if(hPool != VK_NULL_HANDLE)

+                        {

+                            pBlockVector = &hPool->m_BlockVector;

+                        }

+                        else

+                        {

+                            const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();

+                            pBlockVector = m_pBlockVectors[memTypeIndex];

+                        }

+                        pBlockVector->Free(allocation);

+                    }

+                    break;

+                case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:

+                    FreeDedicatedMemory(allocation);

+                    break;

+                default:

+                    VMA_ASSERT(0);

+                }

+            }

+

+            // Do this regardless of whether the allocation is lost. Lost allocations still account to Budget.AllocationBytes.

+            m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());

+            allocation->SetUserData(this, VMA_NULL);

+            m_AllocationObjectAllocator.Free(allocation);

+        }

+    }

+}

+

+VkResult VmaAllocator_T::ResizeAllocation(

+    const VmaAllocation alloc,

+    VkDeviceSize newSize)

+{

+    // This function is deprecated and so it does nothing. It's left for backward compatibility.

+    if(newSize == 0 || alloc->GetLastUseFrameIndex() == VMA_FRAME_INDEX_LOST)

+    {

+        return VK_ERROR_VALIDATION_FAILED_EXT;

+    }

+    if(newSize == alloc->GetSize())

+    {

+        return VK_SUCCESS;

+    }

+    return VK_ERROR_OUT_OF_POOL_MEMORY;

+}

+

+void VmaAllocator_T::CalculateStats(VmaStats* pStats)

+{

+    // Initialize.

+    InitStatInfo(pStats->total);

+    for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)

+        InitStatInfo(pStats->memoryType[i]);

+    for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)

+        InitStatInfo(pStats->memoryHeap[i]);

+

+    // Process default pools.

+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)

+    {

+        VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];

+        VMA_ASSERT(pBlockVector);

+        pBlockVector->AddStats(pStats);

+    }

+

+    // Process custom pools.

+    {

+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);

+        for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)

+        {

+            m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);

+        }

+    }

+

+    // Process dedicated allocations.

+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)

+    {

+        const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);

+        VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);

+        AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];

+        VMA_ASSERT(pDedicatedAllocVector);

+        for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)

+        {

+            VmaStatInfo allocationStatInfo;

+            (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);

+            VmaAddStatInfo(pStats->total, allocationStatInfo);

+            VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);

+            VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);

+        }

+    }

+

+    // Postprocess.

+    VmaPostprocessCalcStatInfo(pStats->total);

+    for(size_t i = 0; i < GetMemoryTypeCount(); ++i)

+        VmaPostprocessCalcStatInfo(pStats->memoryType[i]);

+    for(size_t i = 0; i < GetMemoryHeapCount(); ++i)

+        VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);

+}

+

+void VmaAllocator_T::GetBudget(VmaBudget* outBudget, 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, ++outBudget)

+            {

+                const uint32_t heapIndex = firstHeap + i;

+

+                outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];

+                outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];

+

+                if(m_Budget.m_VulkanUsage[heapIndex] + outBudget->blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])

+                {

+                    outBudget->usage = m_Budget.m_VulkanUsage[heapIndex] +

+                        outBudget->blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];

+                }

+                else

+                {

+                    outBudget->usage = 0;

+                }

+

+                // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.

+                outBudget->budget = VMA_MIN(

+                    m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);

+            }

+        }

+        else

+        {

+            UpdateVulkanBudget(); // Outside of mutex lock

+            GetBudget(outBudget, firstHeap, heapCount); // Recursion

+        }

+    }

+    else

+#endif

+    {

+        for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)

+        {

+            const uint32_t heapIndex = firstHeap + i;

+

+            outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];

+            outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];

+

+            outBudget->usage = outBudget->blockBytes;

+            outBudget->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.

+        }

+    }

+}

+

+static const uint32_t VMA_VENDOR_ID_AMD = 4098;

+

+VkResult VmaAllocator_T::DefragmentationBegin(

+    const VmaDefragmentationInfo2& info,

+    VmaDefragmentationStats* pStats,

+    VmaDefragmentationContext* pContext)

+{

+    if(info.pAllocationsChanged != VMA_NULL)

+    {

+        memset(info.pAllocationsChanged, 0, info.allocationCount * sizeof(VkBool32));

+    }

+

+    *pContext = vma_new(this, VmaDefragmentationContext_T)(

+        this, m_CurrentFrameIndex.load(), info.flags, pStats);

+

+    (*pContext)->AddPools(info.poolCount, info.pPools);

+    (*pContext)->AddAllocations(

+        info.allocationCount, info.pAllocations, info.pAllocationsChanged);

+

+    VkResult res = (*pContext)->Defragment(

+        info.maxCpuBytesToMove, info.maxCpuAllocationsToMove,

+        info.maxGpuBytesToMove, info.maxGpuAllocationsToMove,

+        info.commandBuffer, pStats, info.flags);

+

+    if(res != VK_NOT_READY)

+    {

+        vma_delete(this, *pContext);

+        *pContext = VMA_NULL;

+    }

+

+    return res;

+}

+

+VkResult VmaAllocator_T::DefragmentationEnd(

+    VmaDefragmentationContext context)

+{

+    vma_delete(this, context);

+    return VK_SUCCESS;

+}

+

+VkResult VmaAllocator_T::DefragmentationPassBegin(

+    VmaDefragmentationPassInfo* pInfo,

+    VmaDefragmentationContext context)

+{

+    return context->DefragmentPassBegin(pInfo);

+}

+VkResult VmaAllocator_T::DefragmentationPassEnd(

+    VmaDefragmentationContext context)

+{

+    return context->DefragmentPassEnd();

+

+}

+

+void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)

+{

+    if(hAllocation->CanBecomeLost())

+    {

+        /*

+        Warning: This is a carefully designed algorithm.

+        Do not modify unless you really know what you're doing :)

+        */

+        const uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();

+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();

+        for(;;)

+        {

+            if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)

+            {

+                pAllocationInfo->memoryType = UINT32_MAX;

+                pAllocationInfo->deviceMemory = VK_NULL_HANDLE;

+                pAllocationInfo->offset = 0;

+                pAllocationInfo->size = hAllocation->GetSize();

+                pAllocationInfo->pMappedData = VMA_NULL;

+                pAllocationInfo->pUserData = hAllocation->GetUserData();

+                return;

+            }

+            else if(localLastUseFrameIndex == localCurrFrameIndex)

+            {

+                pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();

+                pAllocationInfo->deviceMemory = hAllocation->GetMemory();

+                pAllocationInfo->offset = hAllocation->GetOffset();

+                pAllocationInfo->size = hAllocation->GetSize();

+                pAllocationInfo->pMappedData = VMA_NULL;

+                pAllocationInfo->pUserData = hAllocation->GetUserData();

+                return;

+            }

+            else // Last use time earlier than current time.

+            {

+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))

+                {

+                    localLastUseFrameIndex = localCurrFrameIndex;

+                }

+            }

+        }

+    }

+    else

+    {

+#if VMA_STATS_STRING_ENABLED

+        uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();

+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();

+        for(;;)

+        {

+            VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);

+            if(localLastUseFrameIndex == localCurrFrameIndex)

+            {

+                break;

+            }

+            else // Last use time earlier than current time.

+            {

+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))

+                {

+                    localLastUseFrameIndex = localCurrFrameIndex;

+                }

+            }

+        }

+#endif

+

+        pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();

+        pAllocationInfo->deviceMemory = hAllocation->GetMemory();

+        pAllocationInfo->offset = hAllocation->GetOffset();

+        pAllocationInfo->size = hAllocation->GetSize();

+        pAllocationInfo->pMappedData = hAllocation->GetMappedData();

+        pAllocationInfo->pUserData = hAllocation->GetUserData();

+    }

+}

+

+bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)

+{

+    // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.

+    if(hAllocation->CanBecomeLost())

+    {

+        uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();

+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();

+        for(;;)

+        {

+            if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)

+            {

+                return false;

+            }

+            else if(localLastUseFrameIndex == localCurrFrameIndex)

+            {

+                return true;

+            }

+            else // Last use time earlier than current time.

+            {

+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))

+                {

+                    localLastUseFrameIndex = localCurrFrameIndex;

+                }

+            }

+        }

+    }

+    else

+    {

+#if VMA_STATS_STRING_ENABLED

+        uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();

+        uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();

+        for(;;)

+        {

+            VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);

+            if(localLastUseFrameIndex == localCurrFrameIndex)

+            {

+                break;

+            }

+            else // Last use time earlier than current time.

+            {

+                if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))

+                {

+                    localLastUseFrameIndex = localCurrFrameIndex;

+                }

+            }

+        }

+#endif

+

+        return true;

+    }

+}

+

+VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)

+{

+    VMA_DEBUG_LOG("  CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);

+

+    VmaPoolCreateInfo newCreateInfo = *pCreateInfo;

+

+    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;

+    }

+

+    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++);

+        VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);

+    }

+

+    return VK_SUCCESS;

+}

+

+void VmaAllocator_T::DestroyPool(VmaPool pool)

+{

+    // Remove from m_Pools.

+    {

+        VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);

+        bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);

+        VMA_ASSERT(success && "Pool not found in Allocator.");

+    }

+

+    vma_delete(this, pool);

+}

+

+void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)

+{

+    pool->m_BlockVector.GetPoolStats(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

+}

+

+void VmaAllocator_T::MakePoolAllocationsLost(

+    VmaPool hPool,

+    size_t* pLostAllocationCount)

+{

+    hPool->m_BlockVector.MakePoolAllocationsLost(

+        m_CurrentFrameIndex.load(),

+        pLostAllocationCount);

+}

+

+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)

+    {

+        if(((1u << memTypeIndex) & memoryTypeBits) != 0)

+        {

+            VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];

+            VMA_ASSERT(pBlockVector);

+            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(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)

+        {

+            if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)

+            {

+                VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();

+                switch(localRes)

+                {

+                case VK_ERROR_FEATURE_NOT_PRESENT:

+                    break;

+                case VK_SUCCESS:

+                    finalRes = VK_SUCCESS;

+                    break;

+                default:

+                    return localRes;

+                }

+            }

+        }

+    }

+

+    return finalRes;

+}

+

+void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)

+{

+    *pAllocation = m_AllocationObjectAllocator.Allocate(VMA_FRAME_INDEX_LOST, false);

+    (*pAllocation)->InitLost();

+}

+

+VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)

+{

+    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;

+    }

+

+    // 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);

+        }

+    }

+    else

+    {

+        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());

+

+    m_Budget.m_BlockBytes[MemoryTypeIndexToHeapIndex(memoryType)] -= size;

+}

+

+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)

+{

+    if(hAllocation->CanBecomeLost())

+    {

+        return VK_ERROR_MEMORY_MAP_FAILED;

+    }

+

+    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. Is the allocation lost?");

+        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. Is the allocation lost?");

+        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();

+    {

+        VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);

+        AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];

+        VMA_ASSERT(pDedicatedAllocations);

+        bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);

+        VMA_ASSERT(success);

+    }

+

+    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);

+

+    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 // #if VMA_MEMORY_BUDGET

+

+void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)

+{

+    if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&

+        !hAllocation->CanBecomeLost() &&

+        (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)

+{

+    bool dedicatedAllocationsStarted = false;

+    for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)

+    {

+        VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);

+        AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];

+        VMA_ASSERT(pDedicatedAllocVector);

+        if(pDedicatedAllocVector->empty() == false)

+        {

+            if(dedicatedAllocationsStarted == false)

+            {

+                dedicatedAllocationsStarted = true;

+                json.WriteString("DedicatedAllocations");

+                json.BeginObject();

+            }

+

+            json.BeginString("Type ");

+            json.ContinueString(memTypeIndex);

+            json.EndString();

+

+            json.BeginArray();

+

+            for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)

+            {

+                json.BeginObject(true);

+                const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];

+                hAlloc->PrintParameters(json);

+                json.EndObject();

+            }

+

+            json.EndArray();

+        }

+    }

+    if(dedicatedAllocationsStarted)

+    {

+        json.EndObject();

+    }

+

+    {

+        bool allocationsStarted = false;

+        for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)

+        {

+            if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)

+            {

+                if(allocationsStarted == false)

+                {

+                    allocationsStarted = true;

+                    json.WriteString("DefaultPools");

+                    json.BeginObject();

+                }

+

+                json.BeginString("Type ");

+                json.ContinueString(memTypeIndex);

+                json.EndString();

+

+                m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);

+            }

+        }

+        if(allocationsStarted)

+        {

+            json.EndObject();

+        }

+    }

+

+    // Custom pools

+    {

+        VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);

+        const size_t poolCount = m_Pools.size();

+        if(poolCount > 0)

+        {

+            json.WriteString("Pools");

+            json.BeginObject();

+            for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)

+            {

+                json.BeginString();

+                json.ContinueString(m_Pools[poolIndex]->GetId());

+                json.EndString();

+

+                m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);

+            }

+            json.EndObject();

+        }

+    }

+}

+

+#endif // #if VMA_STATS_STRING_ENABLED

+

+////////////////////////////////////////////////////////////////////////////////

+// 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) <= 2));

+    VMA_DEBUG_LOG("vmaCreateAllocator");

+    *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);

+    return (*pAllocator)->Init(pCreateInfo);

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(

+    VmaAllocator allocator)

+{

+    if(allocator != VK_NULL_HANDLE)

+    {

+        VMA_DEBUG_LOG("vmaDestroyAllocator");

+        VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;

+        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_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+    allocator->SetCurrentFrameIndex(frameIndex);

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(

+    VmaAllocator allocator,

+    VmaStats* pStats)

+{

+    VMA_ASSERT(allocator && pStats);

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+    allocator->CalculateStats(pStats);

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(

+    VmaAllocator allocator,

+    VmaBudget* pBudget)

+{

+    VMA_ASSERT(allocator && pBudget);

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+    allocator->GetBudget(pBudget, 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);

+    {

+        VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);

+        json.BeginObject();

+

+        VmaBudget budget[VK_MAX_MEMORY_HEAPS];

+        allocator->GetBudget(budget, 0, allocator->GetMemoryHeapCount());

+

+        VmaStats stats;

+        allocator->CalculateStats(&stats);

+

+        json.WriteString("Total");

+        VmaPrintStatInfo(json, stats.total);

+

+        for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)

+        {

+            json.BeginString("Heap ");

+            json.ContinueString(heapIndex);

+            json.EndString();

+            json.BeginObject();

+

+            json.WriteString("Size");

+            json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);

+

+            json.WriteString("Flags");

+            json.BeginArray(true);

+            if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)

+            {

+                json.WriteString("DEVICE_LOCAL");

+            }

+            json.EndArray();

+

+            json.WriteString("Budget");

+            json.BeginObject();

+            {

+                json.WriteString("BlockBytes");

+                json.WriteNumber(budget[heapIndex].blockBytes);

+                json.WriteString("AllocationBytes");

+                json.WriteNumber(budget[heapIndex].allocationBytes);

+                json.WriteString("Usage");

+                json.WriteNumber(budget[heapIndex].usage);

+                json.WriteString("Budget");

+                json.WriteNumber(budget[heapIndex].budget);

+            }

+            json.EndObject();

+

+            if(stats.memoryHeap[heapIndex].blockCount > 0)

+            {

+                json.WriteString("Stats");

+                VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);

+            }

+

+            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) != 0)

+                    {

+                        json.WriteString("DEVICE_LOCAL");

+                    }

+                    if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)

+                    {

+                        json.WriteString("HOST_VISIBLE");

+                    }

+                    if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)

+                    {

+                        json.WriteString("HOST_COHERENT");

+                    }

+                    if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)

+                    {

+                        json.WriteString("HOST_CACHED");

+                    }

+                    if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)

+                    {

+                        json.WriteString("LAZILY_ALLOCATED");

+                    }

+                    if((flags & VK_MEMORY_PROPERTY_PROTECTED_BIT) != 0)

+                    {

+                        json.WriteString(" PROTECTED");

+                    }

+                    if((flags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY) != 0)

+                    {

+                        json.WriteString(" DEVICE_COHERENT");

+                    }

+                    if((flags & VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY) != 0)

+                    {

+                        json.WriteString(" DEVICE_UNCACHED");

+                    }

+                    json.EndArray();

+

+                    if(stats.memoryType[typeIndex].blockCount > 0)

+                    {

+                        json.WriteString("Stats");

+                        VmaPrintStatInfo(json, stats.memoryType[typeIndex]);

+                    }

+

+                    json.EndObject();

+                }

+            }

+

+            json.EndObject();

+        }

+        if(detailedMap == VK_TRUE)

+        {

+            allocator->PrintDetailedMap(json);

+        }

+

+        json.EndObject();

+    }

+

+    const size_t len = sb.GetLength();

+    char* const pChars = vma_new_array(allocator, char, len + 1);

+    if(len > 0)

+    {

+        memcpy(pChars, sb.GetData(), len);

+    }

+    pChars[len] = '\0';

+    *ppStatsString = pChars;

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(

+    VmaAllocator allocator,

+    char* pStatsString)

+{

+    if(pStatsString != VMA_NULL)

+    {

+        VMA_ASSERT(allocator);

+        size_t len = strlen(pStatsString);

+        vma_delete_array(allocator, pStatsString, len + 1);

+    }

+}

+

+#endif // #if 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);

+

+    memoryTypeBits &= allocator->GetGlobalMemoryTypeBits();

+

+    if(pAllocationCreateInfo->memoryTypeBits != 0)

+    {

+        memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;

+    }

+

+    uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;

+    uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;

+    uint32_t notPreferredFlags = 0;

+

+    // Convert usage to requiredFlags and preferredFlags.

+    switch(pAllocationCreateInfo->usage)

+    {

+    case VMA_MEMORY_USAGE_UNKNOWN:

+        break;

+    case VMA_MEMORY_USAGE_GPU_ONLY:

+        if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)

+        {

+            preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;

+        }

+        break;

+    case VMA_MEMORY_USAGE_CPU_ONLY:

+        requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;

+        break;

+    case VMA_MEMORY_USAGE_CPU_TO_GPU:

+        requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;

+        if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)

+        {

+            preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;

+        }

+        break;

+    case VMA_MEMORY_USAGE_GPU_TO_CPU:

+        requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;

+        preferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;

+        break;

+    case VMA_MEMORY_USAGE_CPU_COPY:

+        notPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;

+        break;

+    case VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED:

+        requiredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;

+        break;

+    default:

+        VMA_ASSERT(0);

+        break;

+    }

+

+    // Avoid DEVICE_COHERENT unless explicitly requested.

+    if(((pAllocationCreateInfo->requiredFlags | pAllocationCreateInfo->preferredFlags) &

+        (VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY | VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY)) == 0)

+    {

+        notPreferredFlags |= VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY;

+    }

+

+    *pMemoryTypeIndex = UINT32_MAX;

+    uint32_t minCost = UINT32_MAX;

+    for(uint32_t memTypeIndex = 0, memTypeBit = 1;

+        memTypeIndex < allocator->GetMemoryTypeCount();

+        ++memTypeIndex, memTypeBit <<= 1)

+    {

+        // This memory type is acceptable according to memoryTypeBits bitmask.

+        if((memTypeBit & memoryTypeBits) != 0)

+        {

+            const VkMemoryPropertyFlags currFlags =

+                allocator->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 = VmaCountBitsSet(preferredFlags & ~currFlags) +

+                    VmaCountBitsSet(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;

+}

+

+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;

+    VkBuffer hBuffer = VK_NULL_HANDLE;

+    VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(

+        hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);

+    if(res == VK_SUCCESS)

+    {

+        VkMemoryRequirements memReq = {};

+        allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(

+            hDev, hBuffer, &memReq);

+

+        res = vmaFindMemoryTypeIndex(

+            allocator,

+            memReq.memoryTypeBits,

+            pAllocationCreateInfo,

+            pMemoryTypeIndex);

+

+        allocator->GetVulkanFunctions().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;

+    VkImage hImage = VK_NULL_HANDLE;

+    VkResult res = allocator->GetVulkanFunctions().vkCreateImage(

+        hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);

+    if(res == VK_SUCCESS)

+    {

+        VkMemoryRequirements memReq = {};

+        allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(

+            hDev, hImage, &memReq);

+

+        res = vmaFindMemoryTypeIndex(

+            allocator,

+            memReq.memoryTypeBits,

+            pAllocationCreateInfo,

+            pMemoryTypeIndex);

+

+        allocator->GetVulkanFunctions().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

+

+    VkResult res = allocator->CreatePool(pCreateInfo, pPool);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);

+    }

+#endif

+

+    return res;

+}

+

+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

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);

+    }

+#endif

+

+    allocator->DestroyPool(pool);

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(

+    VmaAllocator allocator,

+    VmaPool pool,

+    VmaPoolStats* pPoolStats)

+{

+    VMA_ASSERT(allocator && pool && pPoolStats);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+    allocator->GetPoolStats(pool, pPoolStats);

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(

+    VmaAllocator allocator,

+    VmaPool pool,

+    size_t* pLostAllocationCount)

+{

+    VMA_ASSERT(allocator && pool);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);

+    }

+#endif

+

+    allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);

+}

+

+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);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordSetPoolName(allocator->GetCurrentFrameIndex(), pool, pName);

+    }

+#endif

+}

+

+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

+        UINT32_MAX, // dedicatedBufferUsage

+        VK_NULL_HANDLE, // dedicatedImage

+        *pCreateInfo,

+        VMA_SUBALLOCATION_TYPE_UNKNOWN,

+        1, // allocationCount

+        pAllocation);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordAllocateMemory(

+            allocator->GetCurrentFrameIndex(),

+            *pVkMemoryRequirements,

+            *pCreateInfo,

+            *pAllocation);

+    }

+#endif

+

+    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

+        UINT32_MAX, // dedicatedBufferUsage

+        VK_NULL_HANDLE, // dedicatedImage

+        *pCreateInfo,

+        VMA_SUBALLOCATION_TYPE_UNKNOWN,

+        allocationCount,

+        pAllocations);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordAllocateMemoryPages(

+            allocator->GetCurrentFrameIndex(),

+            *pVkMemoryRequirements,

+            *pCreateInfo,

+            (uint64_t)allocationCount,

+            pAllocations);

+    }

+#endif

+

+    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

+        UINT32_MAX, // dedicatedBufferUsage

+        VK_NULL_HANDLE, // dedicatedImage

+        *pCreateInfo,

+        VMA_SUBALLOCATION_TYPE_BUFFER,

+        1, // allocationCount

+        pAllocation);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordAllocateMemoryForBuffer(

+            allocator->GetCurrentFrameIndex(),

+            vkMemReq,

+            requiresDedicatedAllocation,

+            prefersDedicatedAllocation,

+            *pCreateInfo,

+            *pAllocation);

+    }

+#endif

+

+    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

+        UINT32_MAX, // dedicatedBufferUsage

+        image, // dedicatedImage

+        *pCreateInfo,

+        VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,

+        1, // allocationCount

+        pAllocation);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordAllocateMemoryForImage(

+            allocator->GetCurrentFrameIndex(),

+            vkMemReq,

+            requiresDedicatedAllocation,

+            prefersDedicatedAllocation,

+            *pCreateInfo,

+            *pAllocation);

+    }

+#endif

+

+    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

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordFreeMemory(

+            allocator->GetCurrentFrameIndex(),

+            allocation);

+    }

+#endif

+

+    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

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordFreeMemoryPages(

+            allocator->GetCurrentFrameIndex(),

+            (uint64_t)allocationCount,

+            pAllocations);

+    }

+#endif

+

+    allocator->FreeMemory(allocationCount, pAllocations);

+}

+

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(

+    VmaAllocator allocator,

+    VmaAllocation allocation,

+    VkDeviceSize newSize)

+{

+    VMA_ASSERT(allocator && allocation);

+

+    VMA_DEBUG_LOG("vmaResizeAllocation");

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+    return allocator->ResizeAllocation(allocation, newSize);

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(

+    VmaAllocator allocator,

+    VmaAllocation allocation,

+    VmaAllocationInfo* pAllocationInfo)

+{

+    VMA_ASSERT(allocator && allocation && pAllocationInfo);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordGetAllocationInfo(

+            allocator->GetCurrentFrameIndex(),

+            allocation);

+    }

+#endif

+

+    allocator->GetAllocationInfo(allocation, pAllocationInfo);

+}

+

+VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(

+    VmaAllocator allocator,

+    VmaAllocation allocation)

+{

+    VMA_ASSERT(allocator && allocation);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordTouchAllocation(

+            allocator->GetCurrentFrameIndex(),

+            allocation);

+    }

+#endif

+

+    return allocator->TouchAllocation(allocation);

+}

+

+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);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordSetAllocationUserData(

+            allocator->GetCurrentFrameIndex(),

+            allocation,

+            pUserData);

+    }

+#endif

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(

+    VmaAllocator allocator,

+    VmaAllocation* pAllocation)

+{

+    VMA_ASSERT(allocator && pAllocation);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK;

+

+    allocator->CreateLostAllocation(pAllocation);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordCreateLostAllocation(

+            allocator->GetCurrentFrameIndex(),

+            *pAllocation);

+    }

+#endif

+}

+

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(

+    VmaAllocator allocator,

+    VmaAllocation allocation,

+    void** ppData)

+{

+    VMA_ASSERT(allocator && allocation && ppData);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+    VkResult res = allocator->Map(allocation, ppData);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordMapMemory(

+            allocator->GetCurrentFrameIndex(),

+            allocation);

+    }

+#endif

+

+    return res;

+}

+

+VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(

+    VmaAllocator allocator,

+    VmaAllocation allocation)

+{

+    VMA_ASSERT(allocator && allocation);

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordUnmapMemory(

+            allocator->GetCurrentFrameIndex(),

+            allocation);

+    }

+#endif

+

+    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);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordFlushAllocation(

+            allocator->GetCurrentFrameIndex(),

+            allocation, offset, size);

+    }

+#endif

+

+    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);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordInvalidateAllocation(

+            allocator->GetCurrentFrameIndex(),

+            allocation, offset, size);

+    }

+#endif

+

+    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);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        //TODO

+    }

+#endif

+

+    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);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        //TODO

+    }

+#endif

+

+    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 vmaDefragment(

+    VmaAllocator allocator,

+    const VmaAllocation* pAllocations,

+    size_t allocationCount,

+    VkBool32* pAllocationsChanged,

+    const VmaDefragmentationInfo *pDefragmentationInfo,

+    VmaDefragmentationStats* pDefragmentationStats)

+{

+    // Deprecated interface, reimplemented using new one.

+

+    VmaDefragmentationInfo2 info2 = {};

+    info2.allocationCount = (uint32_t)allocationCount;

+    info2.pAllocations = pAllocations;

+    info2.pAllocationsChanged = pAllocationsChanged;

+    if(pDefragmentationInfo != VMA_NULL)

+    {

+        info2.maxCpuAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;

+        info2.maxCpuBytesToMove = pDefragmentationInfo->maxBytesToMove;

+    }

+    else

+    {

+        info2.maxCpuAllocationsToMove = UINT32_MAX;

+        info2.maxCpuBytesToMove = VK_WHOLE_SIZE;

+    }

+    // info2.flags, maxGpuAllocationsToMove, maxGpuBytesToMove, commandBuffer deliberately left zero.

+

+    VmaDefragmentationContext ctx;

+    VkResult res = vmaDefragmentationBegin(allocator, &info2, pDefragmentationStats, &ctx);

+    if(res == VK_NOT_READY)

+    {

+        res = vmaDefragmentationEnd( allocator, ctx);

+    }

+    return res;

+}

+

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(

+    VmaAllocator allocator,

+    const VmaDefragmentationInfo2* pInfo,

+    VmaDefragmentationStats* pStats,

+    VmaDefragmentationContext *pContext)

+{

+    VMA_ASSERT(allocator && pInfo && pContext);

+

+    // Degenerate case: Nothing to defragment.

+    if(pInfo->allocationCount == 0 && pInfo->poolCount == 0)

+    {

+        return VK_SUCCESS;

+    }

+

+    VMA_ASSERT(pInfo->allocationCount == 0 || pInfo->pAllocations != VMA_NULL);

+    VMA_ASSERT(pInfo->poolCount == 0 || pInfo->pPools != VMA_NULL);

+    VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->allocationCount, pInfo->pAllocations));

+    VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->poolCount, pInfo->pPools));

+

+    VMA_DEBUG_LOG("vmaDefragmentationBegin");

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+    VkResult res = allocator->DefragmentationBegin(*pInfo, pStats, pContext);

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordDefragmentationBegin(

+            allocator->GetCurrentFrameIndex(), *pInfo, *pContext);

+    }

+#endif

+

+    return res;

+}

+

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(

+    VmaAllocator allocator,

+    VmaDefragmentationContext context)

+{

+    VMA_ASSERT(allocator);

+

+    VMA_DEBUG_LOG("vmaDefragmentationEnd");

+

+    if(context != VK_NULL_HANDLE)

+    {

+        VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+#if VMA_RECORDING_ENABLED

+        if(allocator->GetRecorder() != VMA_NULL)

+        {

+            allocator->GetRecorder()->RecordDefragmentationEnd(

+                allocator->GetCurrentFrameIndex(), context);

+        }

+#endif

+

+        return allocator->DefragmentationEnd(context);

+    }

+    else

+    {

+        return VK_SUCCESS;

+    }

+}

+

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaBeginDefragmentationPass(

+    VmaAllocator allocator,

+    VmaDefragmentationContext context,

+    VmaDefragmentationPassInfo* pInfo

+    )

+{

+    VMA_ASSERT(allocator);

+    VMA_ASSERT(pInfo);

+

+    VMA_DEBUG_LOG("vmaBeginDefragmentationPass");

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+    if(context == VK_NULL_HANDLE)

+    {

+        pInfo->moveCount = 0;

+        return VK_SUCCESS;

+    }

+

+    return allocator->DefragmentationPassBegin(pInfo, context);

+}

+VMA_CALL_PRE VkResult VMA_CALL_POST vmaEndDefragmentationPass(

+    VmaAllocator allocator,

+    VmaDefragmentationContext context)

+{

+    VMA_ASSERT(allocator);

+

+    VMA_DEBUG_LOG("vmaEndDefragmentationPass");

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+    if(context == VK_NULL_HANDLE)

+        return VK_SUCCESS;

+

+    return allocator->DefragmentationPassEnd(context);

+}

+

+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_VALIDATION_FAILED_EXT;

+    }

+    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_VALIDATION_FAILED_EXT;

+    }

+

+    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

+            pBufferCreateInfo->usage, // dedicatedBufferUsage

+            VK_NULL_HANDLE, // dedicatedImage

+            *pAllocationCreateInfo,

+            VMA_SUBALLOCATION_TYPE_BUFFER,

+            1, // allocationCount

+            pAllocation);

+

+#if VMA_RECORDING_ENABLED

+        if(allocator->GetRecorder() != VMA_NULL)

+        {

+            allocator->GetRecorder()->RecordCreateBuffer(

+                allocator->GetCurrentFrameIndex(),

+                *pBufferCreateInfo,

+                *pAllocationCreateInfo,

+                *pAllocation);

+        }

+#endif

+

+        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 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 VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordDestroyBuffer(

+            allocator->GetCurrentFrameIndex(),

+            allocation);

+    }

+#endif

+

+    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_VALIDATION_FAILED_EXT;

+    }

+

+    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

+            UINT32_MAX, // dedicatedBufferUsage

+            *pImage, // dedicatedImage

+            *pAllocationCreateInfo,

+            suballocType,

+            1, // allocationCount

+            pAllocation);

+

+#if VMA_RECORDING_ENABLED

+        if(allocator->GetRecorder() != VMA_NULL)

+        {

+            allocator->GetRecorder()->RecordCreateImage(

+                allocator->GetCurrentFrameIndex(),

+                *pImageCreateInfo,

+                *pAllocationCreateInfo,

+                *pAllocation);

+        }

+#endif

+

+        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 void VMA_CALL_POST vmaDestroyImage(

+    VmaAllocator allocator,

+    VkImage image,

+    VmaAllocation allocation)

+{

+    VMA_ASSERT(allocator);

+

+    if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)

+    {

+        return;

+    }

+

+    VMA_DEBUG_LOG("vmaDestroyImage");

+

+    VMA_DEBUG_GLOBAL_MUTEX_LOCK

+

+#if VMA_RECORDING_ENABLED

+    if(allocator->GetRecorder() != VMA_NULL)

+    {

+        allocator->GetRecorder()->RecordDestroyImage(

+            allocator->GetCurrentFrameIndex(),

+            allocation);

+    }

+#endif

+

+    if(image != VK_NULL_HANDLE)

+    {

+        (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());

+    }

+    if(allocation != VK_NULL_HANDLE)

+    {

+        allocator->FreeMemory(

+            1, // allocationCount

+            &allocation);

+    }

+}

+

+#endif // #ifdef VMA_IMPLEMENTATION